Year: 2020

Abstract:
We provide a practical distance measure in the space of functions parameterized by neural networks. It is based on the classical information distance, and we propose to replace the uncomputable Kolmogorov complexity with information measured by codelength of prequential coding. We also provide a method for directly estimating the expectation of such codelength with limited examples. Empirically, we show that information distance is invariant with respect to different parameterization of the neural networks. We also verify that information distance can faithfully reflect similarities of neural network functions. Finally, we applied information distance to investigate the relationship between neural network models, and demonstrate the connection between information distance and multiple characteristics and behaviors of neural networks.

heading: 1 INTRODUCTION
text: Deep neural networks can be trained to represent complex functions that describe sophisticated input-output relationships, such as image classification and machine translation. Because the functions are highly non-linear and are parameterized in high-dimensional spaces, there is relatively little understanding of the functions represented by deep neural networks. One could interpret deep models by linear approximations (Ribeiro et al., 2016), or from the perspective of piece-wise linear functions, such as in (Arora et al., 2018).
If the space of functions representable by neural networks admits a distance measure, then it would be a useful tool to help analyze and gain insight about neural networks. A major difficulty is the vast number of possibilities of parameterizing a function, which makes it difficult to characterize the similarity given two networks. Measuring similarity in the parameter space is straightforward but is restricted to networks with the same structure. Measuring similarity at the output is also restricted to networks trained on the same task. Similarity of representations produced by intermediate layers of networks is proved to be more reliable and consistent (Kornblith et al., 2019), but is not invariant to linear transformations and can fail in some situations, as shown in our experiments.
In this paper, we provide a distance measure of functions based on information distance (Bennett et al., 1998), which is independent of the parameterization of the neural network. This also removes the arbitrariness of choosing “where” to measure the similarity in a neural network. Information distance has mostly been used in data mining (Cilibrasi & Vitányi, 2007; Zhang et al., 2007). Intuitively, information distance measures how much information is needed to transform one function to the other. We rely on prequential coding to estimate this quantity. Prequential coding can efficiently encode neural networks and datasets (Blier & Ollivier, 2018). If we regard prequential coding as a compression algorithm for neural networks, then the codelength can give an upper bound of the information quantity in a model.
We propose a method for calculating an approximated version of information distance with prequential coding for arbitrary networks. In this method, we use KL-divergence in prequential training and coding, which allow us to directly estimate the expected codelength without any sampling process. Then we perform experiments to demonstrate that this information distance is invariant to the parameterization of the network while also being faithful to the intrinsic similarity of models. Using information distance, we are able to sketch a rough view into the space of deep neural networks and uncover the relationship between datasets and models. We also found that information distance can
help us understand regularization techniques, measure the diversity of models, and predict a model’s ability to generalize.

heading: 2 METHODOLOGY
text: Information distance measures the difference between two objects by information quantity. The information distance between two functions fA and fB can be defined as (Bennett et al., 1998):
d(fA, fB) = max{K(fA|fB),K(fB |fA)} (1)
This definition makes use of Kolmogorov complexity: K(fB |fA) is the length of the shortest program that transforms fA into fB , and information distance d is the larger length of either direction. (Note that this is not the only way to define information distance with Kolmogorov complexity, however we settle with this definition for its simplicity.) Intuitively, this is the minimum number of bits we need to encode fB with the help of fA, or how much information is needed to know fB if fA is already known.
Given two functions fA : X → Y and fB : X → Y ′ defined on the same input space X , each parameterized by a neural network with weights θA and θB , we want to estimate the information distance between fA and fB . The estimation of Kolmogorov complexity term is done by calculating the codelength of prequential coding, so what we get is an upper bound of d, which we denote by dp (p for prequential coding).
2.1 ESTIMATING K(fB |fA) WITH PREQUENTIAL CODING
To send fB to someone who already knows fA, we generate predictions yi from fB using input xi sampled from X . Assume that {xi} is known, we can use prequential coding to send labels {yi}. If we send enough labels, the receiver can use {xi, yi} to train a model to recover fB . If fA and fB have something in common, i.e. K(fB |fA) < K(fB), then with the help of fA we can reduce the codelength used to transmit fB . A convenient way of doing so is to use θA as the initial model in prequential coding. The codelength of k samples is:
Lpreq(y1:k|x1:k) := − k∑ i=1 log pθ̂i(yi|x1:i, y1:i−1) (2)
where θ̂i is the parameter of the model trained on {x1:i−1, y1:i−1}, and θ̂1 = θA. With sufficient large k, the function parameterized by θ̂k would converge to fB .
If both fA and fB are classification models, we can sample y from the output distribution of fB . In this case, the codelength (2) not only transmits fB , but also k specific samples we draw from fB . The information contained in these specific samples is ∑k i=1 log pθB (yi|xi). Because we only care about estimating K(fB |fA), using the “bits-back protocol” (Hinton & van Camp, 1993) the information of samples can be subtracted from the codelength, resulting in an estimation of K(fB |fA) as Lk(fB |fA):
Lk(fB |fA) = − k∑ i=1 log pθ(yi|x1:i, y1:i−1) + k∑ i=1 log pθB (yi|xi) (3)
In practice, we want to use k sufficiently large such that fθ̂k can converge to fB , for example by the criterion
Ex[DKL(fB(x)||fθ̂k(x))] ≤ (4)
However, empirically we found that this often means a large k is needed, which can make the estimation using (3) unfeasible when the number of available x is small. Also the exact value of (3) depends on the specific samples used, introducing variance into the estimation.
2.2 THE PRACTICAL INFORMATION DISTANCE dp
We propose to directly estimate the expectation of Lk(fB |fA), which turns out to be much more efficient in the number of examples x, by leveraging infinite y samples. The expectation of codelength Ey1:k [Lk] over all possible samples y1:k from fB is:
Ey1:k∼fB(x1:k)[Lk(fB |fA)] =− k∑ i=1 Ey1:i log pθ(yi|x1:i, y1:i−1) + k∑ i=1 Eyi log pθB (yi|xi)
≥− k∑ i=1 Eyi logEy1:i−1pθ(yi|x1:i, y1:i−1) + k∑ i=1 Eyi log pθB (yi|xi)
= k∑ i=1 DKL(fB(xi)||Ey1:i−1fθ̂i(xi)) (5)
≈ k∑ i=1 DKL(fB(xi)||fθ̄i(xi)) =: L ′(fB |fA) (6)
In (5), Ey1:i−1fθ̂i(xi) represents an infinite ensemble of models θ̂i estimated from all possible samples y1:i−1. We replace this ensemble with a single model θ̄i that is directly trained on all the samples. θ̄i is trained using KL-divergence as objective, which is equivalent to training with infinite samples (see Appendix A for details from (5) to (6)).
The expected codelength E[Lk] is related, via (6), to the KL-divergence between the output distributions of fB and fθ̄i . Another interpretation of the above estimation is, we finetune model θA with an increasing number of outputs generated by θB , and aggregate the KL-divergence between the two models along the way. The more information fA shares with fB , the faster the KL-divergence decreases, resulting in a lower estimation of K(fB |fA). Now dp is the approximation of (1) we propose in this paper:
dp(fA, fB) = ∧ max{L′(fA|fB), L′(fB |fA)} (7)
2.3 PROPERTIES OF dp
The information distance d in (1) applied to functions defines a metric on the space of functions. Now we check if dp satisfy the axioms of a metric:
1. dp(fA, fB) = 0 ⇔ fA = fB : fA = fB if and only if they always produce the same predictions, which is equivalent to dp(fA, fB) = 0
2. dp(fA, fB) = dp(fB , fA): by definition.
3. dp(fA, fB) ≤ dp(fA, fC) + dp(fC , fB): whether dp keeps this property of d depends on the efficiency of prequential coding, which in turn depends on model optimization.
Another important property of the information distance d is the invariancy with respect to the parameterization of function f . We found that dp is also largely invariant to parameterization of the functions. dp can be used to compare models trained differently, having different structures, or even trained on different tasks. The only condition is that both models should have sufficient expressibility to allow approximation of each other.
There is also a connection between Lk(fB |fA) and the information transfer measure LIT (Zhang et al., 2020):
LkIT (θn) = L preq θ0 (y1:k|x1:k)− Lpreqθn (y1:k|x1:k)
as n→∞, θn → θB , and when yi ∼ fB(xi), we have
E[LkIT (θn)] =E[L preq θA (y1:k|x1:k)]− E[LpreqθB (y1:k|x1:k)] =E[Lk(fB |fA)] (8)

heading: 2.4 DATA-DEPENDENCY AND EQUIVALENT INTERPRETATIONS OF DATA
text: In machine learning, we often only care about the output of a model on the data distribution of the task. Neural network models are trained on input data from a specific domain, for example, image classification models take natural images in RGB format as valid input. It would be meaningless to discuss the behavior of such a model on non-RGB images. This is an important distinction between a neural network function and a function in the mathematical sense.
This motivates us to take a data-dependent formulation of distance measure. In this paper, we limit our discussion to distribution-dependent information distance:
dp(fA, fB) = max{K(f ′A|fB),K(f ′B |fA)} (9) where
f ′A = arg min f∈FA K(f |fB), f ′B = arg min f∈FB K(f |fA) (10)
are equivalencies of fA and fB in the below function family ( can be A or B):
F = {f |Ex∼D[DKL(f(x)||f (x))] ≤ } (11) F is a set containing all the functions producing outputs almost indistinguishable from f , in the expected sense over x drawn from data distribution D. Because they produce almost identical outputs for x ∼ D, we call them equivalent interpretations of data in D. Intuitively, this means that instead of transmitting fB , we can transmit f ′B , which is equivalent to fB on D, if f ′ B can be transmitted in fewer bits.
A quick note on why data-dependency here in the context of neural network models does not break the definition of information distance: if f is a neural network trained on dataset D, then f is fully determined by the information in D plus a random seed (which is of negligible information).
By introducing data-dependency, it enables us to approximate Kolmogorov complexity by coding samples drawn from data distribution D, in other words we can use the training set for coding.

heading: 3 EMPIRICAL STUDY
text: The proposed information distance dp relies on an estimation of Kolmogorov complexity of neural networks with prequential codelength, which unfortunately does not have known theoretical guarantees. Therefore we validate the performance of dp mainly with empirical results. We use experiments to show the advantages of dp and in what situations are dp useful.

heading: 3.1 EXPERIMENT SETUP
text: All experiments in this section are performed using ResNet-56 models (He et al., 2016) on TinyImageNet1, a 200-class image classification dataset. To make the codelength estimation more reliable, we try to achieve lower codelength in prequential coding by optimizing the model estimation process in sequential coding. We performed a hyper-parameter search to select optimal hyperparameters that result in the lowest codelength. Unless otherwise stated, we use k = 10000 in experiments throughout this paper, which we found in most cases allow the difference between the coding model and the reference model Ex[DKL(fB(x)||fθ̂k(x))] to converge.

heading: 3.2 INVARIANCES OF INFORMATION DISTANCE
text: A prominent advantage of information distance is independent of parameterization. Neural networks like multi-layer perceptrons can have a very large number of different configurations (units, weights) that correspond to the same function. Because there is no “canonical” way of parameterizing neural networks, comparing the input-output functions represented by different neural networks can be difficult by merely looking at the network parameters.
There exist many metrics for measuring the similarity or distance between neural networks. But because neural networks are so versatile, similar neural networks can look similar under some metric
1https://tiny-imagenet.herokuapp.com
while very dissimilar by other metrics. There lacks a universal definition of similarity, which is precisely the problem we try to solve with dp.
To empirically examine the invariancy of dp, we evaluated dp under different re-parameterizations of a neural network. We also include a number of distance metrics as baselines for comparison. Descriptions of test scenarios, baselines, and the results are shown in Figure 1. Table 1 summarizes the observed invariancy of distance measures with a quantitative measure.
Results indicates that dp is relatively stable under different kinds of re-parameterization of the network and is the most invariant overall. Other distance measures all exhibit strong dependency on certain kind of parameterization or is inapplicable for some parameterizations. For re-parameterizations that does not change or only minimally change the function f (scaling, neuron swapping, initialization, architecture), dp also exhibit minimal change. For adding perturbations to the network, information distance only starts to increases when the perturbation is large enough. This is because only large noise will start to “wipe out” information in the network. dp is also robust to small adversarial perturbations, while also showing that adversarial perturbations destroy information in the network faster than random noise.
In Initialization experiments, we initialize θA with a network pre-trained on CIFAR-10 (Krizhevsky & Hinton, 2009). dp increase 7% compared to random initialization, because θA carries over some information from CIFAR-10, making θA and θB slightly less similar. In Architecture experiments, if θA uses a different architecture than θB (which is ResNet-56), we also observe increase in dp. The more different the models are (in terms of number of layers) form ResNet-56, the distance dp is also slightly higher. This indicates that while dp is largely invariant to model parameterizations, it is also consistent with intuitive similarities of models. This is not observed with EMD and CKA distances.

heading: 3.3 IS INFORMATION DISTANCE FAITHFUL?
text: Having seen the invariance properties of dp, we next check if dp is faithful to reflect true model distance. Empirically, we verify if dp is aligned with intuitive indicators of model distance. We experiment with two settings: examining model interpolation and the model training progress. These can serve as a sanity-check that dp does reflect differences in the information of models.
In model interpolation we use a straightforward way to manipulate the distance between models: we use two ResNet-56 models θA and θB trained on Tiny-Imagenet, and perform linear interpolation in parameter space to get model θ = (1 − c) θA + c θB . As c change from 0 to 1, the model θ goes smoothly from θA to θB . We apply dp to measure the distance from the interpolated model θ to θB for different c. The results are shown in Figure 2.2
As we interpolate two functions fA and fB in the parameter space, if θA and θB are parameterized similarly, we observe dp(f, fB) to monotonically decrease as f gets closer to fB (Figure 2 left). At the beginning when c is small, increase in c introduces more “fresh information” about fB , thus dp
2To avoid clutter in graphs, we did not include L2 and cosine measures in Figure 2 and 3, as they fail basic invariancy tests in Section 3.2. Full results are given in Appendix B.2.
decreases faster than later in interpolation. On the other hand, if we interpolate two functions that are parameterized differently, because linear mixing of θA and θB in parameter space leads to a degraded network, the distance would first increase then decrease, indicating a loss of information middle in the interpolation. Overall, the general trend of dp agrees with advanced similarity measures like representation EMD and CKA in this scenario.
In the experiment training progress, we use dp to examine the training progress of a model. Starting from θ0, we train the model n epochs to converge and measure the distance from the i-th epoch model θi to the initial model θ0 as well as to the final model θn. Results are shown in Figure 3.
With the training progress after each epoch, dp(fi, f0) steadily decreases and dp(fi, fn) increases. Change in distance is faster in earlier epochs because most of the learning happens in the first few epochs. In this scenario, dp is monotonic with training and correctly depicts the training progress. Both representation EMD and CKA fail to show the dynamics of training beyond the first epoch.
To summarize, parameter space distances fail when function similarity does not correspond to parameter value similarities, and representation space distances can be too noisy to be reliable when similarity is high. Only information distance dp remains faithful in both scenarios.

heading: 4 APPLICATION
text: To illustrate the utility of a universal function distance, we provide a few scenarios where we use dp for understanding and making predictions.

heading: 4.1 SKETCHING THE GEOMETRY OF DATA AND MODEL SPACE
text: A distance measure can help us understand the relationship between datasets and between models. Datasets and models usually live in very high-dimensional spaces, which makes it hard to directly perform a comparison. Instead, we can use dp to get the information distance between datasets and models. In computer vision there is a myriad of datasets and model structures, and we use the Visual Task Adaptation Benchmark (VTAB) (Zhai et al., 2019) as a collection of vision datasets. On each dataset, a model is trained to represent the input-output function of the task. Then we use dp to measure pairwise distances between these functions. To help to visualize the relationship, we use Isometric Mapping (Tenenbaum et al., 2000), a manifold learning algorithm to generate threedimensional embeddings for each function. The distance of points in three-dimensional space is optimized to keep the original structure.
Distances can tell a lot about the relationship between models. In the nine large datasets of VTAB, datasets cluster largely according to the three categories proposed in VTAB (natural, specialized, and structured). CIFAR-100 is very different from any other datasets, but is relatively closer to satellite image datasets than to artificial shape datasets. SVHN (Netzer et al., 2011) is close to 2D shape datasets. The four small datasets are evenly distributed in space: no pair of them is very similar. In terms of model architecture, ResNet variants are relatively similar, while AlexNet (Krizhevsky, 2014) and VGG (Simonyan & Zisserman, 2014) are farther away. VGG with batch normalization
is closer to ResNet than without. ResNet-50, ResNeXt-50 (Xie et al., 2017) and WideResNet-50 (Zagoruyko & Komodakis, 2016) are closest as they are indeed very similar.

heading: 4.2 UNDERSTANDING REGULARIZATIONS
text: Regularization techniques like L2 regularization can bias the learned neural networks toward less complex functions, while for techniques like dropout (Srivastava et al., 2014) and self-distillation (Furlanello et al., 2018), the regularization effect may be less straightforward to explain. We can use dp to examine the (information) complexity of a network f , by measuring its distance dp(f,0) to an empty function.
From Figure 5, we observe that all the listed techniques result in a reduction of dp(f,0), which means that the information complexity of the model function f is reduced. For weight decay, information complexity only starts to decrease after the regularization coefficient is larger than a threshold. Self-distillation has a similar effect to regularization, with the number of distillation iterations controlling regularization strength. This agrees with the theoretical analysis in (Mobahi et al., 2020). Label smoothing and dropout also result in simpler models, highlighting their regularization effect.

heading: 4.3 ENSEMBLES AND MODEL DIVERSITY
text: Distance can be used as an indicator of model diversity: the larger dp between models, the more diverse the models are. Ensembling is a common technique to use the consensus of multiple models to deliver superior performance than a single model. We speculate that a larger model diversity will result in more performance gain from ensembles.
To verify this connection, we train a number of models on Tiny-Imagenet, all to the same performance on the validation set, but with different initializations and different subsets of the training set. Then we choose models in pairs to measure their ensemble performance as well as the distance dp(f1, f2) between them. The result is given in Figure 6, and we found a clear correlation between dp and ensemble performance, and the relationship is about linear. This also indicates that dp captures model diversity.

heading: 4.4 PREDICTING GENERALIZATION
text: Finally, dp is also linked with model generalization. Generalization of neural networks is heavily affected by hyper-parameters and optimization. There have been several works aiming to find the relationship between generalization performance and properties of the network, but it turns out that predicting generalization gap can be a challenging task (Jiang et al., 2019; 2020).
We perform a small-scale experiment to illustrate the connection between information distance and generalization gap. We train a number of models with different hyper-parameters (batch size, learning rate, optimizer, etc.) all to the same loss on the training set, and then measure the distance to a random model by dp(f,0). In Figure 7, we observe that the information complexity of the model is also linked with generalization gap, which also turns out to be a roughly linear relationship. Models that generalize better are farther away from a random model than less performing models.

heading: 5 DISCUSSION AND CONCLUSION
text: The proposed distance dp is based on information distance defined with Komolgorov complexityK. We do not attempt to give a good estimation ofK, but instead relying on the efficiency of prequential coding, we empirically illustrate that dp share the invariance properties of information distance, and reflects the similarity relationships of functions parameterized by neural networks. We also found that dp is linked with behaviors of models, making it a potential tool for analyzing neural networks.
The most notable difference between dp and other similarity metrics is universality. Theoretically rooted in information distance, dp is independent of parameterization and widely applicable in situations involving different tasks and models. However, dp’s utilization of prequential coding also introduces limitations that it might not work in situations where prequential coding fails, for example, when f cannot be efficiently approximated by neural networks.
dp could introduce a potential scale-free, or even parameterization-free geometry of space spanned by neural models. Optimization with manifold descent by dp could also remove the dependency on parameterization, thus avoiding ill-posed conditions in some parameterizations (Dinh et al., 2017).

heading: B EXPERIMENT DETAILS
text: B.1 INVARIANCE EXPERIMENTS
We provide details for re-parametreizations used in invariance experiments:
• Scaling: the weights in layer i is multiplied by c, and the weights in layer i− 1 multiplied by 1/c. For relu networks, this keeps the output of network unchanged.
• Neuron swapping: we randomly permute c·(total number of neurons) neurons in layer i. We also correspondingly permute the input of layer i + 1 so that the network output is unchanged.
• Perturbation: we add Gaussian noise of zero mean and standard deviation c to each individual weight of the network.
• Adversarial perturbation: we add a vector v of standard deviation c to the weight vector of the network, and optimize the vector to maximize deviations of second-to-last layer representations. i.e. maxv:std(v)=cEx[(frθ (x)− frθ+v(x))2]
• Initialization: we experiment with random initialization and initialize with a pre-trained network on another dataset (CIFAR-10).
• Architecture: we use ResNet architecture with different width and depth. ResNet-56-s refers to ResNet-56 with half the width in each layer.
Next we list the baseline distance (or similarity) measures and describe how to calculate them for network fA and fB :
Parameter space distances: we denote the i-th layer weight matrix of network fA as wiA. For L2 and cosine measures, we first flatten and concatenate all weight matrices wiA and biases of the network into a long vector wallA (excluding parameters in batch normalization layers, because some statistic variable in them can be large and dominate the norm of vector w).
• L2: dl2 = ||wallA − wallB ||2. • Cosine: dcosine = wallA · wallB /(||wallA ||2||wallB ||2). • EMD: we use “Optimal Transport of Neurons” in (Li et al., 2020). The distance matrix M
is taken to be the pairwise L2 distance between weights of each neuron
M imn = ||wiAm· − wiBn·||2 The EMD distance is the optimal transport cost of matching neurons from one network to neurons in the other network
demd = min P∈Π(µ,ν) 〈P,M〉F
where P is the optimal transport plan.
Representation space distances: we sample xi from data distribution D and denote the output representation vector of the second-to-last layer of model fA by fAi.
• L2: dl2 = 1k ∑k i=1 ||fAi − fBi||2.
• Cosine: dcosine = 1k ∑k i=1[fAi · fBi/(||fAi||2||fBi||2)]. • EMD: same as in “parameter space distances”, except that the distance matrix M is taken to be the pairwise L2 distance between the activation vector of each neuron
Mmn = ( k∑ i=1 (fAim − fBin)2)1/2
• Linear CKA: we use implementation provided by (Kornblith et al., 2019):
dcka = ||fB·T fA·||2F
||fA·T fA·||F ||fB·T fB·||F where fA· is a a matrix whose k rows are vectors fA1, ..., fAk.
Output space distances: we use the output distributions of fA and fB .
• KL-divergence: Ex[DKL(fA(x)||fB(x))]
B.2 MORE RESULTS OF SECTION 3.3
Figure 8 and 9 shows the results in model interpolation experiments and training progress experiments, for all distance measures studied in this paper. We also show that if each method gives the correct trend, and whether it can be used to identify different models.
B.3 GEOMETRY EXPERIMENTS
From the 19 datasets included in VTAB (Zhai et al., 2019), we were able to download 13 datasets for using in this work. Because the dataset size vary greatly among the 13 datasets, we divide them into two groups: larger datasets (size > 10000), which include:
• cifar100: CIFAR-100 (Krizhevsky & Hinton, 2009)
• svhn: SVHN (Netzer et al., 2011)
• eurosat: EuroSAT (Helber et al., 2019)
• resisc45: Resisc45 (Cheng et al., 2017)
• dsprites position: dSprites/location (Matthey et al., 2017)
• dsprites orientation: dSprites/orientation
• smallnorb azimuth: SmallNORB/azimuth (LeCun et al., 2004)
• smallnorb elevation: SmallNORB/elevation
• dmlab: DMLab (Beattie et al., 2016)
and smaller datasets (size < 10000), which include:
• caltech101: Caltech101 (Li et al., 2006)
• dtd: DTD (Cimpoi et al., 2014)
• oxford flowers102: Flowers102 (Nilsback & Zisserman, 2008)
• oxford iiit pet: Pets (Parkhi et al., 2012)
For larger datasets, we use k = 10000 as with other experiments. For smaller datasets, we use k = 2000. Model is ResNet-56 trained from scratch.
In model geometry experiments, we use the following models trained on ImageNet, as provided by torchvision3:
• resnet18: ResNet-18 (He et al., 2016)
• resnet34: ResNet-34
• resnet50: ResNet-50
• vgg11: VGG-11 without batch normalization (Simonyan & Zisserman, 2014)
• vgg11 bn: VGG-11 with batch normalization
• alexnet: AlexNet (Krizhevsky, 2014)
• resnext50: ResNeXt-50-32x4d (Xie et al., 2017)
• wide resnet50: WideResNet-50-2 (Zagoruyko & Komodakis, 2016)
• densenet121: Densenet-121 (Huang et al., 2017)
• squeezenet: SqueezeNet 1.1 (Iandola et al., 2016)
• mobilenet: MobileNet V2 (Sandler et al., 2018)
Codelength is calculated on the training set of ILSVRC 2012 (Russakovsky et al., 2015).
B.4 ENSEMBLE EXPERIMENTS
We train multiple ResNet-56 models with 2 different random initializations and half of the examples sampled form the TinyImageNet training set. This means the training examples seen by each model can overlap from 0% to 100%. We then select two models out of this collection and ensemble the two models. Ensemble performance and distance between the two models measured by dp(fA, fB) is given in Table 2. We list pairs with same or different initialization, and with different overlap in training examples. Generally speaking, the less the training examples overlaps the larger the distance between the models. Different initialization can also makes the models more dissimilar. Note that from Figure 6, we see that distance dp(fA, fB) is correlated with ensemble performance regardless of whether diversity comes from difference in training examples or difference in initializations.
B.5 GENERALIZATION EXPERIMENTS
We run experiments on CIFAR-10 with different hyperparameters and model configurations, and in all configurations we train the model to cross-entropy loss of 0.1 on training set. Then we measure the generalization gap as the loss on testing set minus the loss on training set. Starting from a default configuration (which is the same hyperparameters we use in other experiments in this paper), each time we modify one of the hyperparameters. Results are listed in Table 3. In terms of studying generalization gap, our experiments is far less thorough than in (Jiang et al., 2020), but here we would like to illustrate the connection between dp with generalization gap under different experiment settings, without spending too many machine hours.

Review summaries:
This paper explores the problem of designing a distance measure in the space of the functions parameterized by neural networks. Ideally, such a measure should be independent of the parameterization of the networks. Also, the measure should support quantifying the distance between the networks with different structures and/or different underlying training tasks. The information distance meets this natural requirement. However, information distance is computational infeasible as it is defined by Kolmogorov complexity.