Year: 2018

Abstract:
Deep neural networks (DNNs) typically have enough capacity to fit random data by brute force even when conventional data-dependent regularizations focusing on the geometry of the features are imposed. We find out that the reason for this is the inconsistency between the enforced geometry and the standard softmax cross entropy loss. To resolve this, we propose a new framework for data-dependent DNN regularization, the Geometrically-Regularized-Self-Validating neural Networks (GRSVNet). During training, the geometry enforced on one batch of features is simultaneously validated on a separate batch using a validation loss consistent with the geometry. We study a particular case of GRSVNet, the Orthogonal-Low-rank Embedding (OLE)-GRSVNet, which is capable of producing highly discriminative features residing in orthogonal low-rank subspaces. Numerical experiments show that OLE-GRSVNet outperforms DNNs with conventional regularization when trained on real data. More importantly, unlike conventional DNNs, OLE-GRSVNet refuses to memorize random data or random labels, suggesting it only learns intrinsic patterns by reducing the memorizing capacity of the baseline DNN.

heading: 1 INTRODUCTION
text: It remains an open question why DNNs, typically with far more model parameters than training samples, can achieve such small generalization error. Previous work used various complexity measures from statistical learning theory, such as VC dimension (Vapnik, 1998), Radamacher complexity (Bartlett & Mendelson, 2002), and uniform stability (Bousquet & Elisseeff, 2002; Poggio et al., 2004), to provide an upper bound for the generalization error, suggesting that the effective capacity of DNNs, possibly with some regularization techniques, is usually limited.
However, the experiments by Zhang et al. (2017) showed that, even with data-independent regularization, DNNs can perfectly fit the training data when the true labels are replaced by random labels, or when the training data are replaced by Gaussian noise. This suggests that DNNs with data-independent regularization have enough capacity to “memorize” the training data. This poses an interesting question for network regularization design: is there a way for DNNs to refuse to (over)fit training samples with random labels, while exhibiting better generalization power than conventional DNNs when trained with true labels? Such networks are very important because they will extract only intrinsic patterns from the training data instead of memorizing miscellaneous details.
One would expect that data-dependent regularizations should be a better choice for reducing the memorizing capacity of DNNs. Such regularizations are typically enforced by penalizing the standard softmax cross entropy loss with an extra geometric loss which regularizes the feature geometry (Lezama et al., 2018; Zhu et al., 2018; Wen et al., 2016). However, regularizing DNNs with an extra geometric loss has two disadvantages: First, the output of the softmax layer, usually viewed as a probability distribution, is typically inconsistent with the feature geometry enforced by the geometric loss. Therefore, the geometric loss typically has a small weight to avoid jeopardizing the minimization of the softmax loss. Second, we find that DNNs with such regularization can still perfectly (over)fit random training samples or random labels. The reason is that the geometric loss (because of its small weight) is ignored and only the softmax loss is minimized.
This suggests that simply penalizing the softmax loss with a geometric loss is not sufficient to regularize DNNs. Instead, the softmax loss should be replaced by a validation loss that is consistent with the enforced geometry. More specifically, every training batch B is split into two sub-batches,
the geometry batch Bg and the validation batch Bv . The geometric loss lg is imposed on the features of Bg for them to exhibit a desired geometric structure. A semi-supervised learning algorithm based on the proposed feature geometry is then used to generate a predicted label distribution for the validation batch, which combined with the true labels defines a validation loss on Bv . The total loss on the training batch B is then defined as the weighted sum l = lg + λlv. Because the predicted label distribution on Bv is based on the enforced geometry, the geometric loss lg can no longer be neglected. Therefore, lg and lv will be minimized simultaneously, i.e., the geometry is correctly enforced (small lg) and it can be used to predict validation samples (small lv). We call such DNNs Geometrically-Regularized-Self-Validating neural Networks (GRSVNets). See Figure 1a for a visual illustration of the network architecture.
GRSVNet is a general architecture because every consistent geometry/validation pair can fit into this framework as long as the loss functions are differentiable. In this paper, we focus on a particular type of GRSVNet, the Orthogonal-Low-rank-Embedding-GRSVNet (OLE-GRSVNet). More specifically, we impose the OLE loss (Qiu & Sapiro, 2015) on the geometry batch to produce features residing in orthogonal subspaces, and we use the principal angles between the validation features and those subspaces to define a predicted label distribution on the validation batch. We prove that the loss function obtains its minimum if and only if the subspaces of different classes spanned by the features in the geometry batch are orthogonal, and the features in the validation batch reside perfectly in the subspaces corresponding to their labels (see Figure 1e). We show in our experiments that OLE-GRSVNet has better generalization performance when trained on real data, but it refuses to memorize the training samples when given random training data or random labels, which suggests that OLE-GRSVNet effectively learns intrinsic patterns.
Our contributions can be summarized as follows:
• We proposed a general framework, GRSVNet, to effectively impose data-dependent DNN regularization. The core idea is the self-validation of the enforced geometry with a consistent validation loss on a separate batch of features.
• We study a particular case of GRSVNet, OLE-GRSVNet, that can produce highly discriminative features: samples from the same class belong to a low-rank subspace, and the subspaces for different classes are orthogonal.
• OLE-GRSVNet achieves better generalization performance when compared to DNNs with conventional regularizers. And more importantly, unlike conventional DNNs, OLEGRSVNet refuses to fit the training data (i.e., with a training error close to random guess) when the training data or the training labels are randomly generated. This implies that OLE-GRSVNet never memorizes the training samples, only learns intrinsic patterns.

heading: 2 RELATED WORK
text: Many data-dependent regularizations focusing on feature geometry have been proposed for deep learning (Lezama et al., 2018; Zhu et al., 2018; Wen et al., 2016). The center loss (Wen et al., 2016) produces compact clusters by minimizing the Euclidean distance between features and their class centers. LDMNet (Zhu et al., 2018) extracts features sampling a collection of low dimensional manifolds. The OLE loss (Lezama et al., 2018; Qiu & Sapiro, 2015) increases inter-class separation and intra-class similarity by embedding inputs into orthogonal low-rank subspaces. However, as mentioned in Section 1, these regularizations are imposed by adding the geometric loss to the softmax loss, which, when viewed as a probability distribution, is typically not consistent with the desired geometry. Our proposed GRSVNet instead uses a validation loss based on the regularized geometry so that the predicted label distribution has a meaningful geometric interpretation.
The way in which GRSVNets impose geometric loss and validation loss on two separate batches of features extracted with two identical baseline DNNs bears a certain resemblance to the siamese network architecture (Chopra et al., 2005) used extensively in metric learning (Cheng et al., 2016; Hadsell et al., 2006; Hu et al., 2014; Schroff et al., 2015; Sun et al., 2014). The difference is, unlike contrastive loss (Hadsell et al., 2006) and triplet loss (Schroff et al., 2015) in metric learning, the feature geometry is explicitly regularized in GRSVNets, and a representation of the geometry, e.g., basis of the low-rank subspace, can be later used directly for the classification of test data.
Our work is also related to two recent papers (Zhang et al., 2017; Arpit et al., 2017) addressing the memorization of DNNs. Zhang et al. (2017) empirically showed that conventional DNNs, even with
data-independent regularization, are fully capable of memorizing random labels or random data. Arpit et al. (2017) argued that DNNs trained with stochastic gradient descent (SGD) tend to fit patterns first before memorizing miscellaneous details, suggesting that memorization of DNNs depends also on the data itself, and SGD with early stopping is a valid strategy in conventional DNN training. We demonstrate in our paper that when data-dependent regularization is imposed in accordance with the validation, GRSVNets will never memorize random labels or random data, and only extracts intrinsic patterns. An explanation of this phenomenon is provided in Section 4.

heading: 3 GRSVNET AND ITS SPECIAL CASE: OLE-GRSVNET
text: As pointed out in Section 1, the core idea of GRSVNet is to self-validate the geometry using a consistent validation loss. To contextualize this idea, we study a particular case, OLE-GRSVNet, where the regularized feature geometry is orthogonal low-rank subspaces, and the validation loss is defined by the principal angles between the validation features and the subspaces.

heading: 3.1 OLE LOSS
text: The OLE loss was originally proposed by Qiu & Sapiro (2015). Consider a K-way classification problem. Let X = [x1, . . . ,xN ] ∈ Rd×N be a collection of data points {xi}Ni=1 ⊂ Rd. Let Xc denote the submatrix of X formed by inputs of the c-th class. Qiu & Sapiro (2015) proposed to learn a linear transformation T : Rd → Rd that maps data from the same class Xc into a low-rank subspace, while mapping the entire data X into a high-rank linear space. This is achieved by solving:
min T:Rd→Rd K∑ c=1 ‖TXc‖∗ − ‖TX‖∗, s.t. ‖T‖2 = 1, (1)
where ‖ · ‖∗ is the matrix nuclear norm, which is a convex lower bound of the rank function on the unit ball in the operator norm (Recht et al., 2010). The norm constraint ‖T‖2 = 1 is imposed to
avoid the trivial solution T = 0. It is proved by Qiu & Sapiro (2015) that the OLE loss (1) is always nonnegative, and the global optimum value 0 is obtained if TXc⊥TXc′ ,∀c 6= c′. Lezama et al. (2018) later used OLE loss as a data-dependent regularization for deep learning. Given a baseline DNN that maps a batch of inputs X into the features Z = Φ(X; θ), the OLE loss on Z is
lg(Z) = K∑ c=1 ‖Zc‖∗ − ‖Z‖∗ = K∑ c=1 ‖Φ(Xc; θ)‖∗ − ‖Φ(X; θ)‖∗. (2)
The OLE loss is later combined with the standard softmax loss for training, and we will henceforth call such network “softmax+OLE.” Softmax+OLE significantly improves the generalization performance, but it suffers from two problems because of the inconsistency between the softmax loss and the OLE loss: First, the learned features no longer exhibit the desired geometry of orthogonal low-rank subspaces. Second, as will be shown in Section 4, softmax+OLE is still capable of memorizing random data or random labels, i.e., it has not reduced the memorizing capacity of DNNs.

heading: 3.2 OLE-GRSVNET
text: We will now explain how to incorporate OLE loss into the GRSVNet framework. First, let us better understand the geometry enforced by the OLE loss by stating the following theorem.
Theorem 1. Let Z = [Z1, . . . ,Zc] be a horizontal concatenation of matrices {Zc}Kc=1. The OLE loss lg(Z) defined in (2) is always nonnegative. Moreover, lg(Z) = 0 if and only if Z∗cZc′ = 0,∀c 6= c′, i.e., the column spaces of Zc and Zc′ are orthogonal.
The proof of Theorem 1, as well as those of the remaining theorems, is detailed in the Appendix. Note that Theorem 1, which ensures that the OLE loss is minimized if and only if features of different classes are orthogonal, is a much stronger result than that by Qiu & Sapiro (2015). We then need to define a validation loss lv that is consistent with the geometry enforced by lg . A natural choice would be the principal angles between the validation features and the subspaces spanned by {Zc}Kc=1. Now we detail the architecture for OLE-GRSVNet. Given a baseline DNN, we split every training batch X ∈ Rd×|B| into two sub-batches, the geometry batch Xg ∈ Rd×|Bg| and the validation batch Xv ∈ Rd×|Bv|, which are mapped by the same baseline DNN into features Zg = Φ(Xg; θ) and Zv = Φ(Xv; θ). The OLE loss lg(Zg) is imposed on the geometry batch to ensure span(Zgc) are orthogonal low-rank subspaces, where span(Zgc) is the column space of Z g c . Let Z g c = UcΣcV ∗ c be the (compact) singular value decomposition (SVD) of Zgc , then the columns of Uc form an orthonormal basis of span(Zgc). For any feature z = Φ(x; θ) ∈ Zv in the validation batch, its projection onto the subspace span(Zgc) is projc(z) = UcU ∗ cz. The cosine similarity between z and projc(z) is then defined as the (unnormalized) probability of x belonging to class c, i.e.,
ŷc = P(x ∈ c) , 〈 z,
projc(z) max (‖projc(z)‖, ε) 〉/ K∑ c′=1 〈 z, projc′(z) max (‖projc′(z)‖, ε) 〉 , (3)
where a small ε is chosen for numerical stability. The validation loss for x is then defined as the cross entropy between the predicted distribution ŷ = (ŷ1, . . . , ŷK)T ∈ RK and the true label y ∈ {1, . . . ,K}. More specifically, let Yv ∈ R1×|Bv| and Ŷv ∈ RK×|Bv| be the collection of true labels and predicted label distributions on the validation batch, then the validation loss is defined as
lv(Y v, Ŷv) =
1 |Bv| ∑ x∈Xv H(δy, ŷ) = − 1 |Bv| ∑ x∈Xv log ŷy, (4)
where δy is the Dirac distribution at label y, and H(·, ·) is the cross entropy between two distributions. The empirical loss l on the training batch X is then defined as
l(X,Y) = l([Xg,Xv], [Yg,Yv]) = lg(Z g) + λlv(Y v, Ŷv). (5)
See Figure 1a for a visual illustration of the OLE-GRSVNet architecture. Because of the consistency between lg and lv , we have the following theorem: Theorem 2. For any λ > 0, and any geometry/validation splitting of X = [Xg,Xv] satisfying Xv contains at least one sample for each class, the empirical loss function defined in (5) is always nonnegative. l(X,Y) = 0 if and only if both of the following conditions hold true:
• The features of the geometry batch belonging to different classes are orthogonal, i.e., span(Zgc)⊥ span(Zgc′),∀c 6= c′
• For every datum x ∈ Xvc , i.e., x belongs to class c in the validation batch, its feature z = Φ(x; θ) belongs to span(Zgc).
Moreover, if l <∞, then rank(span(Zgc)) ≥ 1,∀c, i.e., Φ(·; θ) does not trivially map data into 0.
Remark: The requirement that λ > 0 is crucial in Theorem 2, because otherwise the network can map every input into 0 and achieve the minimum. This is validated in our numerical experiments.
After the training process has finished, we can then map the entire training data Xall = [Xall1 , . . . ,X all K ] (or a random portion of Xall) into their features Zall = Φ(Xall; θ∗), where θ∗ is the learned parameter. The low-rank subspace span(Zallc ) for class c can be obtained via the SVD of Z all c . The label of a test datum x is then determined by the principal angles between z = Φ(x; θ∗) and {span(Zallc )}Kc=1.

heading: 4 TWO TOY EXPERIMENTS
text: Before delving into the implementation details of OLE-GRSVNet, we first present two toy experiments to illustrate our proposed framework. We use VGG-11 (Simonyan & Zisserman, 2014) as the baseline architecture, and compare the performance of the following four DNNs: (a) The baseline network with a softmax classifier (softmax). (b) VGG-11 with weight decay (softmax+wd). (c) VGG-11 regularized by penalizing the softmax loss with the OLE loss (softmax+OLE) (d) OLE-GRSVNet.
We first train these four DNNs on the Street View House Numbers (SVHN) dataset with the original data and labels without data augmentation. The test accuracy and the PCA embedding of the learned test features are shown in Figure 1. OLE-GRSVNet has the highest test accuracy among the comparing DNNs. Moreover, because of the consistency between the geometric loss and the validation loss, the test features produced by OLE-GRSVNet are even more discriminative than softmax+OLE: features of the same class reside in a low-rank subspace, and different subspaces are (almost) orthogonal. Note that in Figure 1e, features of only four classes out of ten (though ideally it should be three) have nonzero 3D embedding (Theorem 2).
Next, we train the same networks, without changing hyperparameters, on the SVHN dataset with either (a) randomly generated labels, or (b) random training data (Gaussian noise). We train the DNNs for 800 epochs to ensure their convergence, and the learning curves of training/testing accuracy are shown in Figure 2. Note that the baseline DNN, with either data-independent or conventional data-dependent regularization, can perfectly (over)fit the training data, while OLE-GRSVNet refuses to memorize the training data when there are no intrinsically learnable patterns.
In another experiment, we generate three classes of one-dimensional data in R10: the data points in the i-th class are i.i.d. samples from the Gaussian distribution with the standard deviation in
the i-th coordinate 50 times larger than other coordinates. Each class has 500 data points, and we randomly shuffle the class labels after generation. We then train a multilayer perceptron (MLP) with 128 neurons in each layer for 2000 epochs to classify these low dimensional data with random labels. We found out that only three layers are needed to perfectly classify these data when using a softmax classifier. However, after incrementally adding more layers to the baseline MLP, we found out that OLE-GRSVNet still refuses to memorize the random labels even for 100-layer MLP. This further suggests that OLE-GRSVNet refuses to memorize training data by brute force when there is no intrinsic patterns in the data. A visual illustration of this experiment is shown in the Appendix.
We provide an intuitive explanation for why OLE-GRSVNet can generalize very well when given true labeled data but refuses to memorize random data or random labels. By Theorem 2, we know that OLE-GRSVNet obtains its global minimum if and only if the features of every random training batch exhibit the same orthogonal low-rank-subspace structure. This essentially implies that OLEGRSVNet is implicitly conducting O(N |B|)-fold data augmentation, where N is the number of training data, and |B| is the batch size, while conventional data augmentation by the manipulation of the inputs, e.g., random cropping, flipping, etc., is typically O(N). This poses a very interesting question: Does it mean that OLE-GRSVNet can also memorize random data if the baseline DNN has exponentially many model parameters? Or is it because of the learning algorithm (SGD) that prevents OLE-GRSVNet from learning a decision boundary too complicated for classifying random data? Answering this question will be the focus of our future research.

heading: 5 IMPLEMENTATION DETAILS OF OLE-GRSVNET
text: Most of the operations in the computational graph of OLE-GRSVNet (Figure 1a) explained in Section 3 are basic matrix operations. The only two exceptions are the OLE loss (Zg → lg((Zg))) and the SVD (Zg → (U1, . . . ,UK)). We hereby specify their forward and backward propagations.

heading: 5.1 BACKWARD PROPAGATION OF THE OLE LOSS
text: According to the definition of the OLE loss in (2), we only need to find a (sub)gradient of the nuclear norm to back-propagate the OLE loss. The characterization of the subdifferential of the nuclear norm is explained by Watson (1992). More specifically, assuming m ≥ n for simplicity, let U ∈ Rm×m,Σ ∈ Rm×n, V ∈ Rn×n be the SVD of a rank-s matrix A. Let U = [U(1),U(2)], V = [V(1),V(2)] be the partition of U, V, respectively, where U(1) ∈ Rm×s and V(1) ∈ Rn×s, then the subdifferential of the nuclear norm at A is:
∂‖A‖∗ = { U(1)V(1)∗ + U(2)WV(2)∗, ∀W ∈ R(m−s)×(n−s) with ‖W‖2 ≤ 1 } , (6)
where ‖ · ‖2 is the spectral norm. Note that to use (6), one needs to identify the rank-s column space of A, i.e., span(U(1)) to find a subgradient, which is not necessarily easy because of the existence of numerical error. Lezama et al. (2018) intuitively truncated the numerical SVD with a small parameter chosen a priori to ensure the numerical stability. We show in the following theorem using the backward stability of SVD that such concern is, in theory, not necessary. Theorem 3. Let Uε,Σε,V be the numerically computed reduced SVD of A ∈ Rm×n, i.e., Uε ∈ Rm×n, Vε ∈ Rn×n, (Uε + δUε)Σε(Vε + δVε)∗ = A + δA = Aε, and ‖δU‖2, ‖δV‖2, ‖δA‖2 are all O(ε), where ε is the machine error. If rank(A) = s ≤ n, and the smallest singular value σs(A) of A satisfies σs(A) ≥ η > 0, we have
d(UεVε∗, ∂‖A‖∗) = O(ε/η). (7)
However, in practice we did observe that using a small threshold (10−6 in this work) to truncate the numerical SVD can speed up the convergence, especially in the first few epochs of training. With the help of Theorem 3, we can easily find a stable subgradient of the OLE loss in (2).
5.2 FORWARD AND BACKWARD PROPAGATION OF Zg → (U1, . . . ,UK)
Unlike the computation of the subgradient in Theorem 3, we have to threshold the singular vectors of Zgc , because the desired output Uc should be an orthonormal basis of the low-rank subspace span(Zgc). In the forward propagation, we threshold the singular vectors Uc such that the smallest singular value is at least 1/10 of the largest singular value.
As for the backward propagation, one needs to know the Jacobian of SVD, which has been explained by Papadopoulo & Lourakis (2000). Typically, for a matrix A ∈ Rn×n, computing the Jacobian of the SVD of A involves solving a total of O(n4) 2 × 2 linear systems. We have not implemented the backward propagation of SVD in this work because this involves technical implementation with CUDA API. In our current implementation, the node (U1, . . . ,UK) is detached from the computational graph during back propagation, i.e., the validation loss lv is only propagated back through the path lv → Ŷv → Zv → θ. Our rational is this: The validation loss lv can be propagated back through two paths: lv → Ŷv → Zv → θ and lv → Ŷv → (U1, . . . ,UK) → Zg → θ. The first path will modify θ so that Zvc moves closer to Uc, while the second path will move Uc closer to Zvc . Cutting off the second path when computing the gradient might decrease the speed of convergence, but numerical experiments suggest that the training process is still well-behaved under such simplification. With such simplification, the only extra computation is the SVD of a mini-batch of features, which is negligible (<5%) when compared to the time of training the baseline network.

heading: 6 EXPERIMENTAL RESULTS
text: In this section, we demonstrate the superiority of OLE-GRSVNet when compared to conventional DNNs in two aspects: (a) It has greater generalization power when trained on true data and true labels. (b) Unlike conventionally regularized DNNs, OLE-GRSVNet refuses to memorize the training samples when given random training data or random labels.
We use similar experimental setup as in Section 4. The same four modifications to three baseline architectures (VGG-11,16,19 (Simonyan & Zisserman, 2014)) are considered: (a) Softmax. (b) Softmax+wd. (c) Softmax+OLE (d) OLE-GRSVNet. The performance of the networks are tested on the following datasets:
• MNIST. The MNIST dataset contains 28× 28 grayscale images of digits from 0 to 9. There are 60,000 training samples and 10,000 testing samples. No data augmentation was used. • SVHN. The Street View House Numbers (SVHN) dataset contains 32× 32 RGB images of
digits from 0 to 9. The training and testing set contain 73,257 and 26,032 images respectively. No data augmentation was used. • CIFAR. This dataset contains 32× 32 RGB images of ten classes, with 50,000 images for
training and 10,000 images for testing. We use “CIFAR+” to denote experiments on CIFAR with data augmentation: 4 pixel padding, 32× 32 random cropping and horizontal flipping.

heading: 6.1 TRAINING DETAILS
text: All networks are trained from scratch with the “Xavier” initialization (Glorot & Bengio, 2010). SGD with Nesterov momentum 0.9 is used for the optimization, and the batch size is set to 200 (a 100/100 split for geometry/validation batch is used in OLE-GRSVNet). We set the initial learning rate to 0.01, and decrease it ten-fold at 50% and 75% of the total training epochs. For the experiments with true labels, all networks are trained for 100, 160 epochs for MNIST, SVHN, respectively. For CIFAR, we train the networks for 200, 300, 400 epochs for VGG-11, VGG16, VGG-19, respectively. In order to ensure the convergence of SGD, all networks are trained for 800 epochs for the experiments with random labels. The mean accuracy after five independent trials is reported.
The weight decay parameter is always set to µ = 10−4. The weight for the OLE loss in “softmax+OLE” is chosen according to Lezama et al. (2018). More specifically, it is set to 0.5 for MNIST and SVHN, 0.5 for CIFAR with VGG-11 and VGG-16, and 0.25 for CIFAR with VGG-19. For OLE-GRSVNet, the parameter λ in (5) is determined by cross-validation. More specifically, we set λ = 10 for MNIST, λ = 5 for SVHN and CIFAR with VGG-11 and VGG-16, and λ = 1 for CIFAR with VGG-19.

heading: 6.2 TESTING/TRAINING PERFORMANCE WHEN TRAINED ON DATA WITH REAL OR RANDOM LABELS
text: Table 1 reports the performance of the networks trained on the original data with real or randomly generated labels. The numbers without parentheses are the percentage accuracies on the test data when networks are trained with real labels, and the numbers enclosed in parentheses are the accuracies on the training data when given random labels. Accuracies on the training data with real labels
(always 100%) and accuracies on the test data with random labels (always close to 10%) are omitted from the table. As we can see, similar to the experiment in Section 4, when trained with real labels, OLE-GRSVNet exhibits better generalization performance than the competing networks. But when trained with random labels, OLE-GRSVNet refuses to memorize the training samples like the other networks because there are no intrinsically learnable patterns. This is still the case even if we increase the number of training epochs to 2000.
We point out that by combining different regularization and tuning the hyperparameters, the test error of conventional DNNs can indeed be reduced. For example, if we combine weight decay, conventional OLE regularization, batch normalization, data augmentation, and increase the learning rate from 0.01 to 0.1, the test accuracy of CIFAR can be pushed to 91.02%. However, this does not change the fact that such network can still perfectly memorize training samples when given random labels. This corroborates the claim by Zhang et al. (2017) that conventional regularization appears to be more of a tuning parameter instead of playing an essential role in reducing network capacity.

heading: 7 CONCLUSION AND FUTURE WORK
text: We proposed a general framework, GRSVNet, for data-dependent DNN regularization. The core idea is the self-validation of the enforced geometry on a separate batch using a validation loss consistent with the geometric loss, so that the predicted label distribution has a meaningful geometric interpretation. In particular, we study a special case of GRSVNet, OLE-GRSVNet, which is capable of producing highly discriminative features: samples from the same class belong to a low-rank subspace, and the subspaces for different classes are orthogonal. When trained on benchmark datasets with real labels, OLE-GRSVNet achieves better test accuracy when compared to DNNs with different regularizations sharing the same baseline architecture. More importantly, unlike conventional DNNs, OLE-GRSVNet refuses to memorize and overfit the training data when trained on random labels or random data. This suggests that OLE-GRSVNet effectively reduces the memorizing capacity of DNNs, and it only extracts intrinsically learnable patterns from the data.
Although we provided some intuitive explanation as to why GRSVNet generalizes well on real data and refuses overfitting random data, there are still open questions to be answered. For example, what is the minimum representational capacity of the baseline DNN (i.e., number of layers and number of units) to make even GRSVNet trainable on random data? Or is it because of the learning algorithm (SGD) that prevents GRSVNet from learning a decision boundary that is too complicated for random samples? Moreover, we still have not answered why conventional DNNs, while fully capable of memorizing random data by brute force, typically find generalizable solutions on real data. These questions will be the focus of our future work.

heading: APPENDIX A PROOF OF THEOREM 1
text: It suffices to prove the case when K = 2, as the case for larger K can be proved by induction. In order to simplify the notation, we restate the original theorem for K = 2:
Theorem. Let A ∈ RN×m and B ∈ RN×n be matrices of the same row dimensions, and [A,B] ∈ RN×(m+n) be the concatenation of A and B. We have
‖[A,B]‖∗ ≤ ‖A‖∗ + ‖B‖∗. (8) Moreover, the equality holds if and only if A∗B = 0, i.e., the column spaces of A and B are orthogonal.
Proof. The inequality (8) and the sufficient condition for the equality to hold is easy to prove. More specifically,
‖[A,B]‖∗ = ‖[A,0] + [0,B]‖∗ ≤ ‖[A,0]‖∗ + ‖[0,B]‖∗ = ‖A‖∗ + ‖B‖∗. (9) Moreover, if A∗B = 0, then
|[A,B]|2 = [A B]∗ [A B] = [ A∗A A∗B B∗A B∗B ] = [ A∗A 0 0 B∗B ] = [ |A| 0 0 |B| ]2 , (10)
where |A| = (A∗A) 12 . Therefore, ‖[A,B]‖∗ = Tr (|[A,B]|) = Tr ([ |A| 0 0 |B| ]) = Tr (|A|) + Tr (|B|) = ‖A‖∗ + ‖B‖∗. (11)
Next, we show the necessary condition for the equality to hold, i.e.,
‖[A,B]‖∗ = ‖A‖∗ + ‖B‖∗ =⇒ A∗B = 0. (12)
Let [
E G G∗ F
] = [ A∗A A∗B B∗A B∗B ] 1 2
= |[A,B]| be a symmetric positive semidefinite matrix. We have  |A|2 = A∗A = E2 + GG∗
|B|2 = B∗B = F2 + G∗G A∗B = EG + GF.
(13)
Let {ai}mi=1, {bi} n i=1 be the orthonormal eigenvectors of |A|, |B|, respectively. Then ‖|A|ai‖2 = 〈 |A|2ai,ai 〉 = 〈 (E2 + GG∗)ai,ai 〉 = ‖Eai‖2 + ‖G∗ai‖2. (14)
Similarly,
‖|B|bi‖2 = ‖Fbi‖2 + ‖Gbi‖2. (15)
Suppose that ‖[A,B]‖∗ = ‖A‖∗ + ‖B‖∗, then
‖A‖∗ + ‖B‖∗ = Tr(|A|) + Tr(|B|) = m∑ i=1 〈|A|ai,ai〉+ n∑ i=1 〈|B|bi, bi〉
= m∑ i=1 ‖|A|ai‖+ n∑ i=1 ‖|B|bi‖
= m∑ i=1 ( ‖Eai‖2 + ‖G∗ai‖2 ) 1 2 + n∑ i=1 ( ‖Fbi‖2 + ‖Gbi‖2 ) 1 2
≥ m∑ i=1 ‖Eai‖+ n∑ i=1 ‖Fbi‖ ≥ m∑ i=1 〈Eai,ai〉+ n∑ i=1 〈Fbi, bi〉 = Tr(E) + Tr(F) = Tr(|[A,B]|) = ‖[A,B]‖∗ = ‖A‖∗ + ‖B‖∗ (16)
Therefore, both of the inequalities in this chain must be equalities, and the first one being equality only if G = 0. This combined with the last equation in (13) implies
A∗B = EG + GF = 0 (17)

heading: APPENDIX B PROOF OF THEOREM 2
text: Proof. First, l is defined in equation (5) as
l(X,Y) = l([Xg,Xv], [Yg,Yv]) = lg(Z g) + λlv(Y v, Ŷv). (18)
The nonnegativity of lg(Zg) is guaranteed by Theorem 1. The validation loss lv(Yv, Ŷv) is also nonnegative since it is the average (over the validation batch) of the cross entropy losses:
lv(Y v, Ŷv) =
1 |Bv| ∑ x∈Xv H(δy, ŷ) = − 1 |Bv| ∑ x∈Xv log ŷy. (19)
Therefore l = lg + λlv is also nonnegative.
Next, for a given λ > 0, l(X,Y) obtains its minimum value zero if and only if both lg(Zg) and lv(Y v, Ŷv) are zeros.
• By Theorem 1, lg(Zg) = 0 if and only if span(Zgc)⊥ span(Zgc′),∀c 6= c′.
• According to (19), lv(Yv, Ŷv) = 0 if and only if ŷ(x) = δy,∀x ∈ Xv, i.e., for every x ∈ Xvc , its feature z = Φ(x; θ) belongs to span(Zgc).
At last, we want to prove that if λ > 0, and Xv contains at least one sample for each class, then rank(span(Zgc)) ≥ 1 for any c ∈ {1, . . . ,K}. If not, then there exists c ∈ {1, . . . ,K} such that rank(span(Zgc)) = 0. Let x ∈ Xv be a validation datum belonging to class y = c. The predicted probability of x belonging to class c is defined in (3):
ŷc = P(x ∈ c) , 〈 z,
projc(z) max (‖projc(z)‖, ε) 〉/ K∑ c′=1 〈 z, projc′(z) max (‖projc′(z)‖, ε) 〉 = 0. (20)
Thus we have
l ≥ λlv = − λ |Bv| ∑ x∈Xv log ŷy ≥ − λ |Bv| log ŷ(x)c = +∞ (21)

heading: APPENDIX C PROOF OF THEOREM 3
text: First, we need the following lemma.
Lemma. Let A ∈ Rm×n be a rank-s matrix, and let A = U(1)Σ(1)V(1)∗ be the compact SVD of A, i.e., U(1) ∈ Rm×s,Σ(1) ∈ Rs×s,V(1) ∈ Rn×s, then the subdifferential of the nuclear norm at A is:
∂‖A‖∗ = { U(1)V(1)∗ + Ũ(2)W̃Ṽ(2)∗ } , (22)
where Ũ(2) ∈ Rm×(n−s), Ṽ(2) ∈ Rn×(n−s), W̃ ∈ R(n−s)×(n−s) satisfy that the columns of Ũ(2) and Ṽ(2) are orthonormal, span(U(1))⊥ span(Ũ(2)), span(V(1))⊥ span(Ṽ(2)), and ‖W̃‖2 ≤ 1.
Proof. Based on (6), we only need to show the following two sets are identical: D1 = { U(1)V(1)∗ + U(2)WV(2)∗, ∀W ∈ R(m−s)×(n−s) with ‖W‖2 ≤ 1 }
(23) D2 = { U(1)V(1)∗ + Ũ(2)W̃Ṽ(2)∗, Ũ(2), Ṽ(2),W̃ satisfy the conditions in the lemma } (24)
On one hand, let d = U(1)V(1)∗ + U(2)WV(2)∗ ∈ D1, and let U(2)W = ŪΣ̄V̄∗ be the reduced SVD of U(2)W ∈ Rm×(n−s), i.e., Ū ∈ Rm×(n−s), Σ̄ ∈ R(n−s)×(n−s), V̄ ∈ R(n−s)×(n−s). Then we can set Ũ(2) = Ū, W̃ = Σ̄V̄∗, and Ṽ(2) = V(2). It is easy to check that Ũ(2), Ṽ(2),W̃ satisfy the conditions in the lemma, and
d = U(1)V(1)∗ + Ũ(2)W̃Ṽ(2)∗ ∈ D2 (25)
On the other hand, let d = U(1)V(1)∗ + Ũ(2)W̃Ṽ(2)∗ ∈ D2, where Ũ(2), Ṽ(2),W̃ satisfy the conditions in the lemma. Let Ũ(2) = U(2)P and Ṽ(2) = V(2)Q, where P ∈ R(m−s)×(n−s) and Q ∈ R(n−s)×(n−s) have orthonormal columns. After setting W = PW̃Q∗, we have
Ũ(2)W̃Ṽ(2)∗ = U(2)PW̃Q∗V(2)∗ = U(2)WV(2)∗, (26)
where ‖W‖2 ≤ 1. Therefore,
d = U(1)V(1)∗ + Ũ(2)W̃Ṽ(2)∗ = U(1)V(1)∗ + U(2)WV(2)∗ ∈ D1 (27)
Now we go on to prove Theorem 3.
Proof. Let rank(A) = s, and we split the computed singular vectors into two parts: Uε = [U(1)ε,U(2)ε], Vε = [V(1)ε,V(2)ε], where U(1)ε ∈ Rm×s, U(2)ε ∈ Rm×(n−s),V(1)ε ∈ Rn×s, and V(2)ε ∈ Rn×(n−s). By the backward stability of SVD, we have ‖U(1) −U(1)ε‖2 = O(ε/η), ‖V(1) −V(1)ε‖2 = O(ε/η), and there exists Ũ(2), Ṽ(2) satisfying the condition in the lemma and ‖Ũ(2) −U(2)ε‖2 = O(ε/η), ‖Ṽ(2) −V(2)ε‖2 = O(ε/η). Because of the lemma, we have (U(1)V(1)∗ + Ũ(2)Ṽ(2)∗) ∈ ∂‖A‖∗, and
d(UεVε∗, ∂‖A‖∗) ≤ ‖UεVε∗ − ( U(1)V(1)∗ + Ũ(2)Ṽ(2)∗ ) ‖2
= ‖ ( U(1)εV(1)ε∗ + U(2)εV(2)ε∗ ) − ( U(1)V(1)∗ + Ũ(2)Ṽ(2)∗ ) ‖2
≤ ‖ ( U(1)ε −U(1) ) V(1)ε∗‖2 + ‖U(1) ( V(1)ε∗ −V(1)∗ ) ‖2
+ ‖ ( U(2)ε − Ũ(2) ) V(2)ε∗‖2 + ‖Ũ(2) ( V(2)ε∗ − Ṽ(2)∗ ) ‖2
= O(ε/η) (28)

heading: APPENDIX D VISUAL ILLUSTRATION OF THE SECOND TOY EXPERIMENT IN
text: SECTION 4

Review summaries:
Previous works have shown that DNNs are able to memorize random training data, even ignoring the enforcing of data-dependent geometric regularization constraints. In this work, authors show convincing results indicating that this is due to a lack of consistency between the main classification loss (typically soft-max cross entropy) and the selected geometric constraint. Consequently, they propose a simple approach where the softmax loss is replaced by a validation loss that is consistent with the enforced geometry. Specifically, for each training batch, instead of considering a join loss (soft-max cross entropy + geometric constraint), they apply a sequential process, where each training batch is split into two sub-batches: a first batch used to apply the geometric constraint, and a second batch (based on the proposed feature geometry) where a validation loss is used to generate a predicted label distribution. Authors test the proposed idea using an implementation that enforces that samples from each class belong to an independent low-rank sub-space (enforced geometric constraint). Results verify the main hypothesis. Specifically, the resulting model is able to fit real data but not data with random labels. The strength of this evaluation is enhanced including results from relevant baselines. In terms of generalization of real data, the proposed approach offers a small increase in accuracy.

The paper proposes a data-dependent regularization method which is coupled with softmax loss to train deep neural networks for classification. The paper turns to Orthogonal Low-rank Embedding (OLE) loss for the geometric constraint that one class of data/feature are assumed to reside on a low-rank subspace that subspaces of different classes are orthogonal ideally. The probability in the softmax is then modeled as cosine similarity between data feature and the class-specific subspaces. In this way, geometric loss and softmax loss have the common goal for optimization. Moreover, during training, the geometry enforced on one batch of features is simultaneously validated on a separate batch using a validation loss. The experiments seem to suggest such a model helps avoid overfitting/memorizing noisy training data. The paper reads well and is easy to follow.