Relative stability toward diffeomorphisms indicates performance in deep nets
Year: 2021

Abstract:
Understanding why deep nets can classify data in large dimensions remains a challenge. It has been proposed that they do so by becoming stable to diffeomorphisms, yet existing empirical measurements support that it is often not the case. We revisit this question by defining a maximum-entropy distribution on diffeomorphisms, that allows to study typical diffeomorphisms of a given norm. We confirm that stability toward diffeomorphisms does not strongly correlate to performance on benchmark data sets of images. By contrast, we find that the stability toward diffeomorphisms relative to that of generic transformations Rf correlates remarkably with the test error t. It is of order unity at initialization but decreases by several decades during training for state-of-the-art architectures. For CIFAR10 and 15 known architectures we find t ≈ 0.2 √ Rf , suggesting that obtaining a smallRf is important to achieve good performance. We study how Rf depends on the size of the training set and compare it to a simple model of invariant learning.

text: √ Rf , suggesting that obtaining a smallRf is important to achieve
good performance. We study how Rf depends on the size of the training set and compare it to a simple model of invariant learning.

heading: 1 Introduction
text: Deep learning algorithms LeCun et al. (2015) are now remarkably successful at a wide range of tasks Amodei et al. (2016); Huval et al. (2015); Mnih et al. (2013); Shi et al. (2016); Silver et al. (2017). Yet, understanding how they can classify data in large dimensions remains a challenge. In particular, the curse of dimensionality associated with the geometry of space in large dimension prohibits learning in a generic setting Luxburg and Bousquet (2004). If high-dimensional data can be learnt, then they must be highly structured.
A popular idea is that during training, hidden layers of neurons learn a representation Le (2013) that is insensitive to aspects of the data unrelated to the task, effectively reducing the input dimension and making the problem tractable Ansuini et al. (2019); Recanatesi et al. (2019); Shwartz-Ziv and Tishby (2017). Several quantities have been introduced to study this effect empirically. It includes (i) the mutual information between the hidden and visible layers of neurons Saxe et al. (2019); Shwartz-Ziv and Tishby (2017), (ii) the intrinsic dimension of the neural representation of the data Ansuini et al. (2019); Recanatesi et al. (2019) and (iii) the projection of the label of the data on the main features of the network Kopitkov and Indelman (2020); Oymak et al. (2019); Paccolat et al. (2021a), the latter being defined from the top eigenvectors of the Gram matrix of the neural tangent kernel (NTK) Jacot et al. (2018). All these measures support that the neuronal representation of the data indeed becomes well-suited to the task. Yet, they are agnostic to the nature of what varies in the data that need not being represented by hidden neurons, and thus do not specify what it is.
Recently, there has been a considerable effort to understand the benefits of learning features for onehidden-layer fully connected nets. Learning features can occur and improve performance when the
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
true function is highly anisotropic, in the sense that it depends only on a linear subspace of the input space Bach (2017); Chizat and Bach (2020); Ghorbani et al. (2019, 2020); Paccolat et al. (2021a); Refinetti et al. (2021); Yehudai and Shamir (2019). For image classification, such an anisotropy would occur for example if pixels on the edge of the image are unrelated to the task. Yet, fully-connected nets (unlike CNNs) acting on images tend to perform best in training regimes where features are not learnt Geiger et al. (2021, 2020); Lee et al. (2020), suggesting that such a linear invariance in the data is not central to the success of deep nets.
Instead, it has been proposed that images can be classified in high dimensions because classes are invariant to smooth deformations or diffeomorphisms of small magnitude Bruna and Mallat (2013); Mallat (2016). Specifically, Mallat and Bruna could handcraft convolution networks, the scattering transforms, that perform well and are stable to smooth transformations, in the sense that ‖f(x)− f(τx)‖ is small if the norm of the diffeomorphism τ is small too. They hypothesized that during training deep nets learn to become stable and thus less sensitive to these deformations, thus improving performance. More recent works generalize this approach to more common CNNs and discuss stability at initialization Bietti and Mairal (2019a,b). Interestingly, enforcing such a stability can improve performance Kayhan and Gemert (2020).
Answering if deep nets become more stable to smooth deformations when trained and quantifying how it affects performance remains a challenge. Recent empirical results revealed that small shifts of images can change the output a lot Azulay and Weiss (2018); Dieleman et al. (2016); Zhang (2019), in apparent contradiction with that hypothesis. Yet in these works, image transformations (i) led to images whose statistics were very different from that of the training set or (ii) were cropping the image, thus are not diffeophormisms. In Ruderman et al. (2018), a class of diffeomorphisms (low-pass filter in spatial frequencies) was introduced to show that stability toward them can improve during training, especially in architectures where pooling layers are absent. Yet, these studies do not address how stability affects performance, and how it depends on the size of the training set. To quantify these properties and to find robust empirical behaviors across architectures, we will argue that the evolution of stability toward smooth deformations needs to be compared relatively to that of any deformation, which turns out to vary significantly during training.
Note that in the context of adversarial robustness, attacks that are geometric transformations of small norm that change the label have been studied Alaifari et al. (2018); Alcorn et al. (2019); Athalye et al. (2018); Engstrom et al. (2019); Fawzi and Frossard (2015); Kanbak et al. (2018); Xiao et al. (2018). These works differ for the literature above and from out study below in the sense that they consider worst-case perturbations instead of typical ones.

heading: 1.1 Our Contributions
text: ◦ We introduce a maximum entropy distribution of diffeomorphisms, that allow us to generate typical diffeomorphisms of controlled norm. Their amplitude is governed by a "temperature" parameter T .
◦ We define the relative stability to diffeomorphisms index Rf that characterizes the square magnitude of the variation of the output function f with respect to the input when it is transformed along a diffeomorphism, relatively to that of a random transformation of the same amplitude. It is averaged on the test set as well as on the ensemble of diffeomorphisms considered.
◦ We find that at initialization, Rf is close to unity for various data sets and architectures, indicating that initially the output is as sensitive to smooth deformations as it is to random perturbations of the image.
◦ Our central result is that after training, Rf correlates very strongly with the test error t: during training, Rf is reduced by several decades in current State Of The Art (SOTA) architectures on four benchmark datasets including MNIST Lecun et al. (1998), FashionMNIST Xiao et al. (2017), CIFAR-10 Krizhevsky (2009) and ImageNet Deng et al. (2009). For more primitive architectures (whose test error is higher) such as fully connected nets or simple CNNs, Rf remains of order unity. For CIFAR10 we study 15 known architectures and find empirically that t ≈ 0.2 √ Rf .
◦ Rf decreases with the size of the training set P . We compare it to an inverse power 1/P expected in simple models of invariant learning Paccolat et al. (2021a).
The library implementing diffeomorphisms on images is available online at github.com/pcslepfl/diffeomorphism. The code for training neural nets can be found at github.com/leonardopetrini/diffeo-sota and the corresponding pre-trained models at doi.org/10.5281/zenodo.5589870.

heading: 2 Maximum-entropy model of diffeomorphisms

heading: 2.1 Definition of maximum entropy model
text: We consider the case where the input vector x is an image. It can be thought as a function x(s) describing intensity in position s = (u, v) ∈ [0, 1]2, where u and v are the horizontal and vertical coordinates. To simplify notations we consider a single channel, in which case x(s) is a scalar (but our analysis holds for colored images as well). We denote by τx the image deformed by τ , i.e. [τx](s) = x(s − τ(s)). τ(s) is a vector field of components (τu(s), τv(s)). The deformation amplitude is measured by the norm
‖∇τ‖2 = ∫
[0,1]2 ((∇τu)2 + (∇τv)2)dudv. (1)
To test the stability of deep nets toward diffeomorphisms, we seek to build typical diffeomorphisms of controlled norm ‖∇τ‖. We thus consider the distribution over diffeomorphisms that maximizes the entropy with a norm constraint. It can be solved by introducing a Lagrange multiplier T and by decomposing these fields on their Fourier components, see e.g. Kardar (2007) or Appendix A. In this canonical ensemble, one finds that τu and τv are independent with identical statistics. For the picture frame not to be deformed, we impose fixed boundary conditions: τ = 0 if u = 0, 1 or v = 0, 1. One then obtains:
τu = ∑
i,j∈N+ Cij sin(iπu) sin(jπv) (2)
where the Cij are Gaussian variables of zero mean and variance 〈C2ij〉 = T/(i2 + j2). If the picture is made of n× n pixels, the result is identical except that the sum runs on 0 < i, j ≤ n. For large n, the norm then reads ‖∇τ‖2 = (π2/2)n2T , and is dominated by high spatial frequency modes. It is useful to add another parameter c to cut-off the effect of high spatial frequencies, which can be simply done by constraining the sum in Eq.2 to i2 + j2 ≤ c2, one then has ‖∇τ‖2 = (π3/8) c2T . Once τ is generated, pixels are displaced to random positions. A new pixelated image can then be obtained using standard interpolation methods. We use two interpolations, Gaussian and bi-linear1, as described in Appendix C. As we shall see below, this choice does not affect our result as long as the diffeomorphism induced a displacement of order of the pixel size, or larger. Examples are shown in Fig.1 as a function of T and c.

heading: 2.2 Phase diagram of acceptable diffeomorphisms
text: Diffeomorphisms are bijective, which is not the case for our transformations if T is too large. When this condition breaks down, a single domain of the picture can break into several pieces, as apparent in Fig.1. It can be expressed as a condition on ∇τ that must be satisfied in every point in space Lowe (2004), as recalled in Appendix B. This is satisfied locally with high probability if ‖τ‖2 1, corresponding to T (8/π3)/c2. In Appendix, we extract empirically a curve of similar form in the (T, c) plane at which a diffeomorphism is obtained with probability at least 1/2 . For much smaller T , diffeomorphisms are obtained almost surely.
Finally, for diffeomorphisms to have noticeable consequences, their associated displacement must be of the order of magnitude of the pixel size. Defining δ2 as the average square norm of the pixel displacement at the center of the image in the unit of pixel size, it is straightforward to obtain from Eq.2 that asymptotically for large c (cf. Appendix B for the derivation),
δ2 = π
4 n2T ln(c). (3)
The line δ = 1/2 is indicated in Fig.1, using empirical measurements that add pre-asymptotic terms to Eq.3. Overall, the green region corresponds to transformations that (i) are diffeomorphisms with high probability and (ii) produce significant displacements at least of the order of the pixel size.
1Throughout the paper, if not specified otherwise, bi-linear interpolation is employed.

heading: 3 Measuring the relative stability to diffeomorphisms
text: Relative stability to diffeomorphisms To quantify how a deep net f learns to become less sensitive to diffeomorphisms than to generic data transformations, we define the relative stability to diffeomorphisms Rf as:
Rf = 〈‖f(τx)− f(x)‖2〉x,τ 〈‖f(x+ η)− f(x)‖2〉x,η . (4)
where the notation 〈〉y can indicate alternatively the mean or the median with respect to the distribution of y. In the numerator, this operation is made over the test set and over the ensemble of diffeomorphisms of parameters (T, c) (on which Rf implicitly depends). In the denominator, the average is on the test set and on the vectors η sampled uniformly on the sphere of radius ‖η‖ = 〈‖τx− x‖〉x,τ . An illustration of what Rf captures is shown in Fig.2. In the main text, we consider median quantities, as they reflect better the typical values of distribution. In Appendix E.3 we show that our results for mean quantities, for which our conclusions also apply.
Dependence of Rf on the diffeomorphism magnitude Ideally, Rf could be defined for infinitesimal transformations, as it would then characterize the magnitude of the gradient of f along smooth deformations of the images, normalized by the magnitude of the gradient in random directions. However, infinitesimal diffeomorphisms move the image much less than the pixel size, and their definition thus depends significantly on the interpolation method used. It is illustrated in the left panels of Fig.3, showing the dependence of Rf in terms of the diffeomorphism magnitude (here characterised by the mean displacement magnitude at the center of the image δ) for several interpolation methods. We do see that Rf becomes independent of the interpolation when δ becomes of order unity. In what follows we thus focus on Rf (δ = 1), which we denote Rf .
SOTA architectures become relatively stable to diffeomorphisms during training, but are not at initialization The central panels of Fig.3 show Rf at initialization (shaded), and after training (full) for two SOTA architectures on four benchmark data sets. The first key result is that, at initialization, these architectures are as sensitive to diffeomorphisms as they are to random transformations. Relative stability to diffeomorphisms at initialization (guaranteed theoretically in some cases Bietti and Mairal (2019a,b)) thus does not appear to be indicative of successful architectures.
By contrast, for these SOTA architectures, relative stability toward diffeomorphisms builds up during training on all the data sets probed. It is a significant effect, with values of Rf after training generally found in the range Rf ∈ [10−2, 10−1]. Standard data augmentation techniques (translations, crops, and horizontal flips) are employed for training. However, the results we find only mildly depend on using such techniques, see Fig.12 in Appendix.
Learning relative stability to diffeos requires large training sets How many data are needed to learn relative stability toward diffeomorphisms? To answer this question, newly initialized networks are trained on different training-sets of size P . Rf is then measured for CIFAR10, as indicated in the right panels of Fig.3. Neural nets need a certain number of training points (P ∼ 103) in order to become relatively stable toward smooth deformations. Past that point, Rf monotonically decreases with P . In a range of P , this decrease is approximately compatible with the an inverse behavior Rf ∼ 1/P found in the simple model of Section 6. Additional results for MNIST and FashionMNIST can be found in Fig.13, Appendix E.3.
Simple architectures do not become relatively stable to diffeomorphisms To test the universality of these results, we focus on two simple architectures: (i) a 4-hidden-layer fully connected (FC) network (FullConn-L4) where each hidden layer has 64 neurons and (ii) LeNet LeCun et al. (1989) that consists of two convolutional layers followed by local max-pooling and three fully-connected layers.
Measurements of Rf for these networks are shown in Fig.4. For the FC net, Rf ≈ 1 at initialization (as observed for SOTA nets) but grows after training on the full data set, showing that FC nets do not learn to become relatively stable to smooth deformations. It is consistent with the modest evolution of Rf (P ) with P , suggesting that huge training sets would be required to obtain Rf < 1. The situation is similar for the primitive CNN LeNet, which only becomes slightly insensitive (Rf ≈ 0.6) in a single data set (CIFAR10), and otherwise remains larger than unity.
Layers’ relative stability monotonically increases with depth Up to this point, we measured the relative stability of the output function for any given architecture. We now study how relative stability builds up as the input data propagate through the hidden layers. In Fig.14 of Appendix E.3, we report Rf as a function of depth for both simple and deep nets. What we observe is Rf0 ≈ 1 independently
2With the only exception of the ImageNet results (central panel) in which only one trained network is considered.
of depth at initialization, and monotonically decreases with depth after training. Overall, the gain in relative stability appears to be well-spread through the net, as is also found for stability alone Ruderman et al. (2018).

heading: 4 Relative stability to diffeomorphisms indicates performance
text: Thus, SOTA architectures appear to become relatively stable to diffeomorphisms after training, unlike primitive architectures. This observation suggests that high performance requires such a relative stability to build up. To test further this hypothesis, we select a set of architectures that have been relevant in the state of the art progress over the past decade; we systematically train them in order to compare Rf to their test error t. Apart from fully connected nets, we consider the already cited LeNet (5 layers and ≈ 60k parameters); then AlexNet Krizhevsky et al. (2012) and VGG Simonyan and Zisserman (2015), deeper (8-19 layers) and highly over-parametrized (10-20M (million) params.) versions of the latter. We introduce batch-normalization in VGGs and skip connections with ResNets. Finally, we go to EfficientNets, that have all the advancements introduced in previous models and achieve SOTA performance with a relatively small number of parameters (<10M); this is accomplished by designing an efficient small network and properly scaling it up. Further details about these architectures can be found in Table 1, Appendix E.2.
The results are shown in Fig.5. The correlation between Rf and t is remarkably high (corr. coeff.3 : 0.97), suggesting that generating low relative sensitivity to diffeomorphisms Rf is important to obtain good performance. In Appendix E.3 we also report how changing the train set size P affects the position of a network in the ( t, Rf ) plane, for the four architectures considered in the previous section (Fig.18). We also show that our results are robust to changes of δ, c (Fig.21) and data sets (Fig.20).
What architectures enable a low Rf value? The latter can be obtained with skip connections or not, and for quite different depths as indicated in Fig.5. Also, the same architecture (EfficientNetB0) trained by transfer learning from ImageNet – instead of directly on CIFAR10 – shows a large improvement both in performance and in diffeomorphisms invariance. Clearly, Rf is much better predicted by t than by the specific features of the architecture indicated in Fig.5.
5 Stability toward diffeomorphisms vs. noise
The relative stability to diffeomorphisms Rf can be written as Rf = Df/Gf where Gf characterizes the stability with respect to additive noise and Df the stability toward diffeomorphisms:
Gf = 〈‖f(x+ η)− f(x)‖2〉x,η 〈‖f(x)− f(z)‖2〉x,z , Df = 〈‖f(τx)− f(x)‖2〉x,τ 〈‖f(x)− f(z)‖2〉x,z . (5)
Here, we chose to normalize these stabilities with the variation of f over the test set (to which both x and z belong), and η is a random noise whose magnitude is prescribed as above. Stability toward additive noise has been studied previously in fully connected architectures Novak et al. (2018) and for CNNs as a function of spatial frequency in Tsuzuku and Sato (2019); Yin et al. (2019).
The decrease of Rf with growing training set size P could thus be due to an increase in the stability toward diffeomorphisms (i.e. Df decreasing with P ) or a decrease of stability toward noise (Gf increasing with P ). To test these possibilities, we show in Fig.6 Gf (P ), Df (P ) and Rf (P ) for MNIST, Fashion MNIST and CIFAR10 for two SOTA architectures. The central results are that (i) stability toward noise is always reduced for larger training sets. This observation is natural: when more data needs to be fitted, the function becomes rougher. (ii) Stability toward diffeomorphisms does not behave universally: it can increase with P or decrease depending on the architecture and the training set. Additionally, Gf and Df alone show a much smaller correlation with performance than Rf– see Figs.15,16,17 in Appendix E.3.

heading: 6 A minimal model for learning invariants
text: In this section, we discuss the simplest model of invariance in data where stability to transformation builds up, that can be compared with our observations of Rf above. Specifically, we consider the "stripe" model Paccolat et al. (2021b), corresponding to a binary classification task for Gaussiandistributed data points x = (x‖, x⊥) where the label function depends only on one direction in data space, namely y(x) = y(x‖). Layers of y = +1 and y = −1 regions alternate along the direction x‖, separated by parallel planes. Hence, the data present d − 1 invariant directions in input-space denoted by x⊥ as illustrated in Fig.7-left.
When this model is learnt by a one-hidden-layer fully connected net, the first layer of weights can be shown to align with the informative direction Paccolat et al. (2021a). The projection of these weights
3Correlation coefficient: Cov(log t,logRf )√ Var(log t)Var(logRf ) .
on the orthogonal space vanishes with the training set size P as 1/ √ P , an effect induced by the sampling noise associated to finite training sets.
In this model, Rf can be defined as:
Rf = 〈‖f(x‖, x⊥ + ν)− f(x‖, x⊥)‖2〉x,ν
〈‖f(x+ η)− f(x)‖2〉x,η , (6)
where we made explicit the dependence of f on the two linear subspaces. Here, the isotropic noise ν is added only in the invariant directions. Again, we impose ‖η‖ = ‖ν‖. Rf (P ) is shown in Fig. 7-right. We observe that Rf (P ) ∼ P−1, as expected from the weight alignment mentioned above. Interestingly, Fig.3 for CIFAR10 and SOTA architectures support that the 1/P behavior is compatible with the observations for some range of P . In Appendix E.3, Fig.13, we show analogous results for MNIST and Fashion-MNIST. We observe the 1/P power-law scaling for ResNets. It suggests that for these architectures, learning to become invariant to diffeomorphisms may be limited by a naive measure of sampling noise as well. By contrast for EfficientNets, in which the decrease in Rf is more limited, a 1/P behavior cannot be identified.

heading: 7 Discussion
text: A common belief is that stability to random noise (small Gf ) and to diffeomorphisms (small Df ) are desirable properties of neural nets. Its underlying assumption is that the true data label mildly depends on such transformations when they are small. Our observations suggest an alternative view:
1. Figs.6,16: better predictors are more sensitive to small perturbations in input space.
2. As a consequence, the notion that predictors are especially insensitive to diffeomorphisms is not captured by stability alone, but rather by the relative stability Rf = Df/Gf .
3. We propose the following interpretation of Fig.5: to perform well, the predictor must build large gradients in input space near the decision boundary – leading to a large Gf overall. Networks that are relatively insensitive to diffeomorphisms (small Rf ) can discover with less data that strong gradients must be there and generalize them to larger regions of input space, improving performance and increasing Gf .
This last point can be illustrated in the simple model of Section 6, see Fig.7-left panel. Imagine two data points of different labels falling close to the – e.g. – left true decision boundary. These two points can be far from each other if their orthogonal coordinates differ. Yet, if Rf = 0 (now defined in Eq.6), then the output does not depend on the orthogonal coordinates, and it will need to build a strong gradient – in input space – along the parallel coordinate to fit these two data. This strong gradient will exist throughout that entire decision boundary, improving performance but also increasing Gf . Instead, if Rf = 1, fitting these two data will not lead to a strong gradient, since they can be far from each other in input space. Beyond this intuition, in this model decreasing Rf can quantitatively be shown to increase performance, see Paccolat et al. (2021b).

heading: 8 Conclusion
text: We have introduced a novel empirical framework to characterize how deep nets become invariant to diffeomorphisms. It is jointly based on a maximum-entropy distribution for diffeomorphisms, and on the realization that stability of these transformations relative to generic ones Rf strongly correlates to performance, instead of just the diffeomorphisms stability considered in the past.
The ensemble of smooth deformations we introduced may have interesting applications. It could serve as a complement to traditional data-augmentation techniques (whose effect on relative stability is discussed in Fig.12 of the Appendix). A similar idea is present in Hauberg et al. (2016); Shen et al. (2020) but our deformations have the advantage of being easier to sample and data agnostic. Moreover, the ensemble could be used to build adversarial attacks along smooth transformations, in the spirit of Alaifari et al. (2018); Engstrom et al. (2019); Kanbak et al. (2018). It would be interesting to test if networks robust to such attacks are more stable in relative terms, and how such robustness affects their performance.
Finally, the tight correlation between relative stability Rf and test error t suggests that if a predictor displays a given Rf , its performance may be bounded from below. The relationships we observe t(Rf ) may then be indicative of this bound, which would be a fundamental property of a given data set. Can it be predicted in terms of simpler properties of the data? Introducing simplified models of data with controlled stability to diffeomorphisms beyond the toy model of Section 6 would be useful to investigate this key question.

heading: Acknowledgements
text: We thank Alberto Bietti, Joan Bruna, Francesco Cagnetta, Pascal Frossard, Jonas Paccolat, Antonio Sclocchi and Umberto M. Tomasini for helpful discussions. This work was supported by a grant from the Simons Foundation (#454953 Matthieu Wyart).

Review summaries:
The authors consider the relationship between the performance of modern deep neural network architectures trained on standard benchmark natural image datasets and their relationship to stability with respect to smooth deformations of the input image. These issues have been studied previously in the context of (natural) adversarial examples and in theoretically-constructed (i.e. non-trainable) networks -- the motivation and contribution here is to examine them through the lens of trained networks as well. To study this issue empirically, the authors introduce a maximum-entropy distribution on diffeomorphisms, which (I believe) amounts to constructing the deformation vector field as a (gaussian) random combination of periodic Fourier basis functions with frequency-dependent weights; they undertake an empirical investigation of the properties of this distribution in order to find parameter regimes where it produces realistic small-magnitude diffeomorphisms of the image plane (rather than distorting it beyond recognition, or doing nothing). They then use this tool to construct a computational "relative diffeomorphism stability" metric, which is the average stability of a predictor with respect to such diffeomorphisms divided by the predictor's average stability with respect to scale-appropriate gaussian noise perturbations, called $R_f$. With $R_f$, several findings are reported: across numerous modern architectures (ResNet18; EfficientNet) and datasets (CIFAR10; ImageNet), randomly-initialized networks have $R_f$ near unity and it decreases after training; $R_f$ decreases with the size of the training set (measured by subsampling); and test set performance correlates well with $R_f$ after training in the context of the CIFAR10 dataset. The authors present a toy theoretical model to give a theoretical corroboration of the $R_f$ parameter's behavior for a shallow network, and provide some ablation studies in the context of presence or not of data augmentation in the training process and the type of interpolation used to apply the diffeomorphisms.  

This paper introduces a new quantity called "relative stability" that strongly correlates with the classification performance of state of the art architectures on standard datasets. This quantity is a ratio between the variation of the features with respect to diffeomorphic transformation of the images and simple additive transformations.  To do so, the authors propose to use a parametrized set of diffemorphisms with bounded L2 norm of the derivative.  The dependence on the training set is highlighted, in particular a given amount of data is necessary to see the "relative stability" decrease with the size training set. Last, a simple synthetic experiment is proposed that illustrates the expected behaviour.    

This work contributes a framework for characterizing the invariance of image classifiers to diffeomorphisms. It is based on the empirical index $R_f$, which measures the stability to random diffeomorphisms relative to stability to additive noise. The authors find that $R_f$ is strongly correlated with classifier performance for a wide array of image classifiers. The results suggest that an image classifier's generalization performance is strongly related to its invariance to certain diffeomorphisms, as opposed to additive noise.

This paper investigates the role of stability to the action of diffeomorphisms in the classification performances of deep neural networks. Surprisingly, it shows that stability measurements are good indicators to compare the performance of deep neural network classifiers even for complex image data bases. The paper introduces stability measurements of diffeomorphism actions over images and shows that these measurement correlate strongly with the classification errors obtained by different CNN architectures over MNIST and CIFAR. The paper also shows that the stability to diffeomorphisms decreases when the training sizes decreases and gives a simple model to explain this phenomenon.