Kaleidoscope: An Efficient, Learnable Representation For All Structured Linear Maps
Authors: Tri Dao
Nimit Sohoni
Albert Gu
Matthew Eichhorn
Amit Blonder
Megan Leszczynski
Atri Rudra
Christopher Ré
Venue:  (2020)
Keywords: structured matrices
efficient ML
algorithms
butterfly matrices
arithmetic circuits

Abstract: Modern neural network architectures use structured linear transformations, such as low-rank matrices, sparse matrices, permutations, and the Fourier transform, to improve inference speed and reduce memory usage compared to general linear maps. However, choosing which of the myriad structured transformations to use (and its associated parameterization) is a laborious task that requires trading off speed, space, and accuracy. We consider a different approach: we introduce a family of matrices called kaleidoscope matrices (K-matrices) that provably capture any structured matrix with near-optimal space (parameter) and time (arithmetic operation) complexity. We empirically validate that K-matrices can be automatically learned within end-to-end pipelines to replace hand-crafted procedures, in order to improve model quality. For example, replacing channel shuffles in ShuffleNet improves classification accuracy on ImageNet by up to 5%. K-matrices can also simplify hand-engineered pipelines---we replace filter bank feature computation in speech data preprocessing with a learnable kaleidoscope layer, resulting in only 0.4% loss in accuracy on the TIMIT speech recognition task. In addition, K-matrices can capture latent structure in models: for a challenging permuted image classification task, adding a K-matrix to a standard convolutional architecture can enable learning the latent permutation and improve accuracy by over 8 points. We provide a practically efficient implementation of our approach, and use K-matrices in a Transformer network to attain 36% faster end-to-end inference speed on a language translation task.

Published as a conference paper at ICLR 2020
KALEIDOSCOPE: AN EFFICIENT, LEARNABLE REPRE- SENTATION FOR ALL STRUCTURED LINEAR MAPS
Tri Dao ', Nimit Sharad Sohoni*?, " Albert Gu Matthew Eichhorn 3, Amit Blonder +
Megan Leszczynski 1, Atri Rudra 1 Christopher Ré
Department of Computer Science, Stanford University
2 Institute for Computational and Mathematical Engineering, Stanford University
3 Center for Applied Mathematics, Cornell University
4 Department of Computer Science and Engineering, University at Buffalo, The State University of New York (trid, n nims, a bertgu) @stan edu, m mleezczyysst edu, at ri wwrrriiuffall... edu, chrismre@cs stanford.edu
edd,, amitbl amitblon@be onê ffafffloo wffffllleeee edd,
ABSTRACT
Modern neural network architectures use structured linear transformations, such as low-rank matrices, sparse matrices, permutations, and the Fourier transform, to im- prove inference speed and reduce memory usage compared to general linear maps. However, choosing which of the myriad structured transformations use (and its associated parameterization) is a laborious task that requires trading off speed, space, and accuracy. We consider different approach: introduce family of matrices called kaleidoscope matrices (K-matrices) that provably capture any struc- tured matrix with near-optimal space (parameter) and time (arithmetic operation) complexity. We empirically validate that K-matrices can be automatically learned within end-to-end pipelines replace hand-crafted procedures, in order improve model quality. For example, replacing channel shuffles in ShuffleNet improves classification accuracy on ImageNet by up to 5%. K-matrices can also simplify hand-engineered pipelines we replace filter bank feature computation in speech data preprocessing with a learnable kaleidoscope layer, resulting in only 0.4% loss in accuracy the TIMIT speech recognition task. In addition, K-matrices capture latent structure in models: for challenging permuted image classification task, K K-matrix based representation of permutations is able to learn the right latent structure and improves accuracy of downstream convolutional model by over 9%. We provide practically efficient implementation of our approach, and use K-matrices in a Transformer network to attain 36% faster end-to-end inference speed on a language translation task.
INTRODUCTION
Structured linear maps are fundamental and ubiquitous in modern machine learning. Their effi- ciency in speed (fast algorithms) and space (few parameters) reduce computation and memory usage. The class of structured linear maps includes fixed specialized transforms such as the discrete Fourier transform (DFT) and Hadamard transform used in signal processing (Cooley al. 1969). convolutions for image, language, and speech modeling (Gu et al. (008)), and low-rank and sparse matrices for efficient storage and inference on edge devices (Yu et al., (017). Forms of structure such sparsity have been at the forefront of recent advances in ML (Frankle & Carbin 2019). and are critical for on-device and energy-efficien models, two application areas of tremendous recent interest (sicuuko 2019 Schwartz et al. 2019).
There are plethora of classes of structured linear maps, each with significantly different repre- sentation, algorithm, and implementation. They have different tradeoffs in terms of inference speed, training speed, and accuracy, and the conventional wisdom is that no one class works uniformly well across all applications. As result, ML practitioners currently hand-pick specific classes of structured linear maps for each of their applications. This a difficult and labor-intensee task.
'These authors contributed equally.

---

Published as a conference paper at ICLR 2020
Ideally, these problems should be addressed with universal representation for structured linear maps: (i) Such parameterization should be expressive enough to capture important classes of structure, with nearly tight parameter count and runtime: the space required to represent the linear map should be close to optimal, and the resulting algorithm for matrix vector multiplication should be close to the fastest possible algorithm. (ii) The parameterization should be differentiable in order be learned as a component of end-to-end ML pipelines, enabling it to easily be used as drop-in replacement for manually engineered structured components. (iii) The parameterization should admit practically efficient algorithms for training and inference, in terms of both speed and memory.
Currently, no class of structured linear maps satisfies all of these criteria. Most existing classes of structured matrices-suce as the class of low-rank matrices- fail to tightly capture other important types of structure. For example, the DFT has an efficient structured representation of size On log n),, yet cannot be well-approximated by low-rank transform of size < n²² Another important type of structure is sparsity; lots of exciting recent work has focused on the design of sparse neural networks. For instance, sparse networks of comparable quality to their dense counterparts--yet an order of magnitude fewer parameters- be created via pruning (Han et al. (016) or by identifying "winning lottery tickets" (Frankle & Carbin 2019). In parallel, recent theoretical results by De Sa eet al. (2018) show that sparsity and the notion of structure in linear maps are fundamentally linked: any given matrix can be factored into a product of sparse matrices with total parameter count equal to the efficiency (i.e. minimum arithmetic circuit complexity) of the matrix. In other words, the representation of linear maps as products of sparse matrices tightly captures all forms of structure. Unfortunately, it is difficult to actually learn these sparse factorizations, because it requires finding the sparsity patterns of the factors- a discrete, nondifferentiable search problem. Thus, current methods for training sparse neural networks are either expensive (Frankle & Carbin 2019) or rely on highly hand-tuned heuristics for evolving the sparsity patterns throughout training (Dettmers & Zettlemoyer 2019).
By contrast, we propose a representation of linear maps as products of sparse matrices with specific predefined sparsity patterns (Section 2) and show that it does satisfy our desiderata: it retains the expressiveness of unstructured sparsity, while being differentiably learnable and efficient like other structured representations. Concretely, our representation is based on products of particular building block known as a butterfly matrix (Parker 1995 Dao et al. 2019); we term such products kaleidoscope matrices (K-matrices for short) [
(i) Our main theoretical contribution (Section 2.3) concerns the expressiveness of this representation: we show that any structured linear map (i.e. one that can be applied using s < 2 arithmetic operations) can be represented as a K-matrix, with a nearly tight number of parameters and algorithmic complexity (both on the order of s up to logarithmic factors). (ii) The kalcidoscope representation is fully differentiable; thus, all the parameters of a K-matrix can be learned using standard optimization algorithms such as SGD. (iii) Because of their simple, regular structure, K-matrices are practical and easy to use. We provide memory- and runtime-efficient implementations of K-matrix multiplication on CPU and GPU for training and inference, with a simple PyTorch interface.
We empirically validate that, due to their expressiveness, learnability, and efficiency, we can use K K-matrices as a drop-in replacement for linear components deep learning models. In Section 3.1 we use K-matrices to replace hand-crafted structure in two different settings. We simplify the six steps of filter bank computation in speech preprocessing into a single learnable K-matrix step, with only an 0.4% accuracy drop on the TIMIT speech recognition task. We use K-matrices to replace channel shuffles in ShuffleNet, improving ImageNet classification accuracy by up to 5%. In Section 3.2 we show that K-matrices can successfully recover latent structure; K-matrix is used to learn latent permutations in a permuted image dataset (Permuted CIFAR), resulting in 9 points higher accuracy in downstream CNN model. In Section 3.3 we show that our efficient K-matrix multiplication implementation can be applied to speed up weal-world tasks: we replace linear layers with K- k-matrices in Con--oooo------nnnnnn network to attain 36% faster end-to-end inference speed with a 1.0 drop in BLEU score on the IWSLT14 Berman->Enghen translation task.
'A group of butterflies is known as kaleidoscope.
2

---

Published as a conference paper at ICLR 2020
2 A NEARLY-TIGHT PARAMETERIZATION OF ALL STRUCTURED MATRICES
We first present some background on the characterization of all structured matrices (i.e. those with subquadratic multiplication algorithms) products of sparse factors, along with the definition of butterfly matrices. We then propose differentiable family of kaleidoscope matrices, composed of products of butterfly matrices, and prove their expressivity: all structured matrices can be represented in this form, with almost optimal parameter count and runtime.
2.1 BACKGROUND: SPARSE FACTORIZATION, BUTTERFLY Y MATRICES
Sparse factorization One method of constructing matrices with theoretically fast matrix- vector multiplication algorithms is as product of sparse matrices, that multiplication by arbitrary vector has cost proportional to the total number of nonzeros (NNZ) of the matrices in the product. Surprisingly, the converse is also true. [D Sa et al. (2018) introduce the concept of sparse product width (SPW), which roughly corresponds to the total NNZ in factorization of a matrix, and show that it is asymptotically optimal descriptor of the algorithmic complexity of matrix-vector multiplication (Bürgisser et al. 2013). We use a similar argument in the proof of our main theorem (Section 2.3) However, attempting to learn such factorization of given matrix is difficult, the sparsity constraint is not continuous. Moreover, because of the possibly irregular sparsity patterns, it difficult realize the theoretical speedups in practice (Gray al. 2017 Gahvari al. 2007).
Butterfly matrices Butterfly matrices, encoding the recursive fast Fourier transform (FFT) algorithm, have long been used in numerical linear algebra (Parker 1995: Li et al.) 2015) and machine learning (Mathieu & LeCun [014]) Jing et al. [2017] Munkhoeva et al. 2018 Dao al. 2019) 2 Choromanski et 20.]9. Here we deñie butterfly matrices, which we use as a building block for our hierarchy of kaleidoscope matrices.
structure of the
Definition 2.1. A butterfly factor of size 2 (denoted as B₁) is a matrix of the form B₁ =
D, D2 where each D; &/ x diagonal matrix. We restrict k to be power 2.
D3
Daj
Definition 2.2. A butterfly factor matrix of size with block size k (denoted B(()) is block
diagonal matrix of a (possibly different) butterfly factors of size k:
B = diag (Bxl1 [Bll....., [Bx]
Definition 2.3. A butterfly matrix of size n (denoted as B(a) is malrix that can be expressed as
product of butterfly factor matrices: ((n) B(")) ((") (n)
... ...".))) Equivalently, may define ((n)
recursively as a matrix that can be expressed in the following form:
B (
B m))
B
0
B B
(Note that [B(+]] and [B(+]]p 22 may be different.)
2.2 THE KALEIDOSCOPE HIERARCHY
Using the building block of butterfly matrices, we formally define the kaleidoscope (BB*) hicrarchy and prove its expressiveness. This class of matrices serves fully differentiable alternative to products of sparse matrices (Section 2.T. with similar expressivity. In Appendix T we show where various common structured matrix classes are located within this hierarchy.
The building block for this hierarchy is the product of butterfly matrix and the (conjugate) transpose of another butterfly matrix (which is simply product of butterfly factors taken in the opposite order). Figure T visualizes the sparsity patterns of the butterfly factors in BB", where the red and blue dots represent the allowed locations of nonzero entries.
Definition 2.4 (Kaleidoscope hierarchy, kaleidoscope matrices).
Define B as the set of all matrices that can be expressed in the form B(x) (for some n.).
Define BB as the set of matrices M of the form M M,M; for some M1, M2 B.
3

---

Published as a conference paper at ICLR 2020
B
[B
Visualization of the fixed sparsity pattern of the building blocks in BB", in the case n = 16. The red and blue dots represent all the possible locations of the nonzero entries.
Figure I:
Define (BB*)" thh as the set of matrices M that can be expressed as M M M2M,, with each M, E BB (1 S w). (The notation w represents width.)
Define (B as the sel of n x n matrices M that can be expressed as M- = SEST for some
en matrix E E (BB*) where S E Ruxenn [In 0 ... 0] (i.e. M the upper-left corner of E). (The notation represents expansion relative to n.)
M is a kaleidoscope matrix, abbreviated as K-matrix, if M E (BB*) )2e for some w and e.
The kaleidoscope hierarchy, or (BB*) hierarchy, refers to the families of matrices (BB*), S (BB*)² S ...., for fixed expansion factor e. Each butterfly matrix can represent the identity matrix, so (BB*)² S (BB*)=+1 We show that the inclusion is proper in Appendix F This
hierarchy generalizes the BP hierarchy proposed by Dao et al. (2019), as shown Appendix
Efficiency in space and speed Each matrix in (BB*) ) is product of 2w total butterfly matrices and transposes of butterfly matrices, each of which is in turn a product of log(ne) factors with 2ne nonzeros (NNZ) each. Therefore, each matrix in (BB*)² !M has 4wne log(ne) parameters and matrix-vector multiplication algorithm of complexity O (wne log ne) (by multiplying the vector with each sparse factor sequentially). We prove this more formally in Appendix For the applications in Section 3] w: and are small constants (up to 2), so those K-matrices have On log n) parameters and runtime.
2.3 ALL LOW-DEPTH STRUCTURED MATRICES ARE IN THE KALEIDOSCOPE HIERARCHY
We now present our main theoretical result: the fact that general linear transformations, expressed as low-depth linear arithmetic circuits, are captured in the BB hierarchy with low width. Arithmetic circuits are commonly used to formalize algebraic algorithmic complexity (Bürgisser et al. 2013); we include a primer on this in Appendix M The quantities of interest are the total number of gates in the circuit, representing the total number of steps required perform the algorithm for serial processor, and the depth, representing the minimum number of steps required for a parallel processor.
Theorem 1. Let M be an n n matrix such that multiplication of M times an arbitrary vector v can O(4) be represented as a linear arithmetic circuit with 8 total gates and depth Then, M E (BB* )orgy
The representation of such matrix M in the BB* hierarchy has O(ds log s) parameters and yields a (ds log s) multiplication algorithm, compared to the O(s) parameters and runtime of the circuit representation. To the best our knowledge, the most general classes of efficient matrices that have been studied (De Sa et al. 2018) have depth d on the order of log n or poly log n. In these cases, the representation with K- K-matrices matches the best known bounds up to polylogarithmie factors.
The crux of the proof of Theorem (shown in Appendix F is the construction of an almost tight representation of any sparse matrix as a K-matrix (i.e. a product butterfly matrices); specifically,
o{ [([+]) (Theorem 3 Appendix II.
we show that any n x n sparse matrix with nonzeros is in (BB**) )o(1)
We then leverage the expressivity result of products of sparse matrices to represent all arithmetue circuits (similar to the sparse product width result De Sa et al. (2018) referenced in Section 2.1 to complete the proof of Theorem
This intermediate result is also a novel characterization of sparse matrices. For a matrix with s NNZ. the kaleidoscope representation has O(s log n)) parameters and runtime, instead of the optimal (ss) parameters and runtime; so, we trade off an extra logarithmic factor in space and time for full differentiability (thanks to the fixed sparsity patterns in the representation). The intuition behind
4

---

Published as a conference paper at ICLR 2020
the result is follows: sparse matrix with NNZ can be written as sum of [s/n] matrices each with at most n NNZ. Any n x n matrix with at most n NNZ, up to permuting the rows and columns, is product of two butterfly matrices (Lemmaa I.I) Sorting networks (Knuth 1997) imply that permutation matrices in fact in BB (Theorem 2 Appendix G). We thus obtain a kaleidoscope representation for each summand matrix with (n log n) parameters. By the addition closure property of the BB" hierarchy (Lemma H.5), each sparse matrix with NNZ then has a kaleidoscope representation with ( log n) parameters.
in (BB*) ) but tighten the result to show that they
Tight representation for structured linear maps common in ML Even though Theorem I sug- gests that the kaleidoscope representation can be loose by logarithmic factors, many structured linear maps common in ML can be represented in this hierarchy with an optimal number of parameters and runtime compared to the best known parameterizations, several examples such as discrete transforms (the DFT, discrete cosine transform (DCT), discrete sine transform (DST), and Hadamard transform), convolution (i.e. circulant matrices), Toeplitz matrices (Gray 2006), structured matrices for kernel approximation ((HD) (Yu al. (2016) and compact neural network design (Fastfood (I et al.] 2013), ACDC (Moczulski et al. (0166). There have been other large classes of structured matrices proposed in the machine learning literature, such Toeplitz-like (Sindhwani et al. (2015) and low displacement rank (LDR) (Thomas et al., 2018), but they are not known to be able to capture these common structures as tightly as K-matrices can, More detailed discussions are in Appendix
to constant factors. Appendix ( includes
2.4 EXTENSIONS
ReLU networks with low-depth structured weight matrices In Appendix L we prove that finding an efficient circuit for ReLU network can be reduced to finding efficient circuits for each of its weight matrices, with at most constant factor greater size and run-time (i.e. number of gates). We also show that ReLU networks with kaleidoscope weight matrices have near-lineat VC dimension in the number of parameters, matching the bound for networks with unconstrained weight matrices (Bartlett al.) 1999: Harvey et al., 2017) and LDR (Thomas et al. 2018). This yields corresponding sample complexity bound.
Orthogonal kaleidoscope hierarchy Orthogonal butterfly matrices are commonly used variant due to their improved stability (Parker 1995), where each butterfly factor is constrained to be
C
S
orthogonal:
with C, S being diagonal and C2 + S2 I. Similar to the BB" hierarchy, in
C
Appendix K we define the OBB hierarchy consisting of products of orthogonal butterfly matrices and diagonal matrices, and show that this hierarchy has the same expressiveness as the BB* hierarchy.
3 EMPIRICAL EVALUATION
We validate three claims that suggest that kaleidoscopes are a promising technique to learn different types of structure in modern architectures.
1. Section 3.1
for applications in speech and lightweight computer vision relying on highly hand-crafted structured transformations, show that quality of such architectures by simply replacing existing hand-structured components with K-matrices, with only small overhead in memory and computation.
recover- and even improve- the
2. In Section 3.2, for challenging task with latent structure (Permuted CIFAR-10), K-matrix- based relaxation of permutations is able to learn the right latent permutation, yielding 9 points better accuracy in downstream CNN compared standard RNN and CNN baselines used on such permuted image classification tasks.
3. In Section 3.3] we show that, although not yet highly optimized, our current implementation of K-matrices can improve the inference throughput of DynamicCony Transformer, of the-art fast machine translation model, by 36%, with only a relatively small drop in translation quality.
5

---

Published as a conference paper at ICLR 2020
In all of the above applications, K-matrices are fully differentiable, simply train them jointly with the rest of the model using standard learning algorithms (such as SGD). Full details for all the experiments (precise architectures, hyperparameters, etc.) are in Appendix B
3.1 REPLACING HAND-CRAFTED STRUCTURES
We validate that kaleidoscope matrices can recover improve on the performance of hand-crafted structure in MI. models. For example, a single learnable kaleidoscope layer can be used to replace the hand-engineered filter bank speech preprocessing pipeline with only 0.4% loss in accuracy on the TIMIT speech recognition task (Section B.I.I. Replacing channel shuffles in ShuffleNet with learnable K-matrices improves classification accuracy on ImageNet by up 5.0% (Section 3.1.2
3.1.1 SPEECH PREPROCESSING
Filter bank (MFSC) features
to
Normalae
Row aualo
Framiig
Kalli dalcode layer
w/Kaleidoscope
Figure 2: Comparison of the standard MFSC featurization pipeline with "kaleidoscope" pipeline.
We show that K-matrices can remove the need for hand-tuning by significantly simplifying speech recognition data preprocessing pipelines. In particular, we can entirely replace the complex hand- crafted MFSC featurization commonly used in speech recognition tasks with a fully learnable kaleidoscope layer, with only 0.4% drop in accuracy on the TIMIT speech recognition benchmark. Results are presented in Table Our approach is competitive with the accuracy of standard models that use hand-crafted features, and significantly outperforms current approaches for learning from raw audio input.
Table 1: TIMIT phoneme error rate (PER%) for different methods. Our kaleidoscope, raw-input version of the model (row 3) performs competitively with the original model trained on MFSC features (row 1), with only an 0.4% drop in PER. significantly outperforms existing approaches that learn from raw audio, i.c. without handcrafted featurization (e.g. SincNet [row 2], which to our knowledge attains the previous state-of-the-ar for learning from raw audio), and is only 0.8% less accurate than the overall sftteoof-hh-and TIMIT Additional comparisons given in Appendix B.1
Method
Test set PER%
Raw audio input
MFSC features + LSTM
14.2
SincNet (Ravanelli et al. 2019
17.2
Kaleidoscope + LS77M
14.6
Modern speech recognition models currently rely on carefully hand-crafted features extracted from the audio, which are then fed into an acoustic model. By contrast, learning directly from the raw audio-ia i.e. end-to-end learning from the audio waveform without any manual catturiiatiooovvviinn the need for this complicated and often expensive preprocessing step. There have been recent attempts learn directly from raw audio, such SincNet (Ravanelli Bengio 2018); however, they often rely specialized architectures designed by domain experts. Instead, we use standard RNN speech recognition architecture, but use learnable kaleidoscope layer to replace the featurization steps.
"Code that implements Kaleidoscope matrix multiplication is available https::/ com/ Hazykesearch/ earning--ee rcuits
'The current state tfte--of-hhe-rtt results from Ravanelli et al. (018 use concatenation of three different speech audio CituriiaationsMMSCC MFCC, and fMI.RR-B the neural network input, along with customized RNN architecture (LiGRU) specifically designed for speech recognition.

---

Published as a conference paper at ICLR 2020
The baseline architecture takes as input filter bank (MFSC) features, which are a popular standard featurization for speech recognition (Paliwal| 1999) and involve several steps hand-crafted specifically for this domain. These features are extracted from the raw audio waveform, and fed as the input into a Bi-LSTTM model. We significantly simplify this pipeline by replacing the featurization step with trainable kaleidoscope layer that is trained end-to-end together with the Bi-LSTM.. The original pipeline and our modified kaleidoscope version are depicted in Figure [
The computation of MFSC features involves a series of painstakingly hand-designed steps (further described in Appendix B.I). each involving their own hyperparameters: (i) the waveform is framed (split into chunks), (ii) the waveform is dithered (noise added), (iii) pre-emphasis is applied, (iv) the Hamming window is applied, (v) the FFT is applied and the power spectrum is computed. (vi) the result is mapped to the mel scale (which involves applying a particular linear transformation and then taking the logarithm of the result), (vii) cepstral mean and variance normalization is applied. We replace the last six steps (ii-vi) vii) of this featurization process with a learnable kaleidoscope layer; specifically, after windowing, we multiply the input by K-matrix, and then compute the logarithm of the power spectrum; the output is fed into the Bi-LSTM model.
3.1.2 REPLACING CNN CHANNEL SHUFFLE
We evaluate how K-matrices can improve the quality of hand-crafted, lightweight architectures for computer vision tasks, without the need for hand-tuning. We select ShuffleNet (Zhang et 2018)) which state-of-the-ar lightweight CNN architecture that uses a manually designed "channel shuffle" permutation matrix to improve performance. By replacing this fixed permutation with a learnable K-matrix, we achieve up to 5% further improvement in classification accuracy, without hand-tuned components and with modest space penalty of up to 10%. Results are given in Table 2
Table 2: Top-1 classification accuracy of ShuffleNet on ImageNet validation set (parameter counts in parentheses). We compare our approach (col. 3) with our reimplementation of "vanilla" ShuffleNet (col. 1) and recent approach based on the Hadamard transform (col. 2) We report results for different network width multipliers (# channels). The last column shows the differences in accuracy and parameter count between our approach and vanilla ShuffleNet; using a learnable K-matrix in place of each fixed permutation (shuffle) or Hadamard matrix improves accuracy by up to 5%.
Shuffle
Hadamard
Kaleidoscope (K.)
K. vs. Shuffle
0.25 ShuffleNet g8
44.1% (0.46M)
43.9% (0.46M)
49.2% (0.51M)
+5.0% (+0.05M)
0.5 ShuffleNet g8
57.1% (1.0M)
56.2% (1.0M)
59.5% (1.1M)
+2.4% (+0.1M)
1.0 ShuffleNet g8
65.3% (2.5M)
65.0% (2.5M)
66.5% (2.8M)
+1.2% (+0.2M)
Grouped convolution (Krizhevsky et al. 2012) is often used reduce parameter count and speed up inference compared to standard convolution, but, by default, channels in different groups cannot exchange information. To remedy this, ShuffleNet uses a permutation matrix to shuffle the channels after each grouped convolution. ZZhao et al.] (2019) propose to instead use the Hadamard transform before and after each grouped convolution to mix the channels. place of these hand-engineered solutions, we use a K-matrix before and after each grouped convolution, and learn these end-to-end together with the rest of the network. As shown in Table 2 across a range of sizes, replacing the channel shuffles with K-matrices results in improved performance at comparable parameter counts.
3.2 LEARNING A LATENT PERMUTATION
We show that K-matrices can be used in a challenging task for which existing classes of structured linear maps have not been found suitable. We investigate the problem of image classification on a permuted image dataset (Permuted CIFAR-10). This problem is challenging due to the discrete nature of learning the latent permutation of the dataset; we present differentiable relaxation for this using a K-matrix as a key component. Results are presented in Table 3 compared to methods that do
'Despite our best effort, we were unable to reproduce the original accuracy reported by Zhang et al. 20188) problem similarly faced by /hhao et (2019) and and[_y et al. (2019). /Zhao et al. (2019) use block Hadamard transform and pre-activation ShuffleNet, so their results not directly comparable with those reported here.
7

---

Published as a conference paper at ICLR 2020
not have a permutation learning step, our approach gets points higher accuracy (84.4% 93.6%), coming within points of the accuracy on the un ne-ppemmued dataset (94.9%).
Table 3:
Permuted CIFAR-IO validation classification accuracy (%). Our kaleidoscope layer is able to nearly perfectly recover the latent structure, allowing a downstream CNN to approach the accuracy of standard ResNet18 on the unpermuted dataset (last column).
Model
FC
RNN
CNN
Dense + CNN
K + CNN
Unpermuted
Accuracy 61.2
57.8
73.7
84.4
93.6
94.9
In this task, we use a permuted image classification dataset (Permuted CIFAR-10), 10), wherein fixed global permutation is applied to the pixels of every image in the original input set. Typically, only fully-connected (FC) and recurrent models are applied such datasets (Le al. 2015), because the permutation destroys locality in the image, presenting difficulty for CNNs. However, CNNs are much better-suited for standard image tasks. We thus expect that learning the permutation and then applying a standard CNN should outperform these baselines. As mentioned in Section 2 the kaleidoscope hierarchy provides a nearly tight parameterization permutations; this makes them a natural fit for the permutation learning step.
Experimentally, we use a K-matrix to represent a distribution over permutations, which converges to single permutation at the end of training. The correct latent structure is learned by applying samples from this distribution to the permuted training images, and minimizing an auxiliary smoothness- based loss that encourages the reconstructed images to be more "natural" (i.e. vary smoothly pixel-to-pixel) The learned permutation is evaluated by training ResNet18 8 with the K-matrix permutation layer inserted the beginning. Full details of our approach are provided in Appendix B33
In Table 3 we compare our approach to a ResNet18 without this extra K-matrix layer, a ResNet1 with an extra dense matrix at the beginning instead of a K-matrix, and other baselines. As generic representations such as unstructured matrices do not have the requisite properties to fit in the pipeline, these baselines fail to effectively learn the latent permutation. We emphasize that a K-matrix provides this ability to recover latent structure despite not being specialized for permutations. Figure describes the pipeline and displays examples of permuted and unpermuted images.
Kaleidoscope
Classitttinn
iber
Sampled permutaiion
30
Smoothneu
085
Figure 3: (a) (Left) Schematic describing permutation learning approach. The inputs are multiplied by a K-matrix and then fed into CNN, from which the classification loss is computed. Separately, the input is permuted by permutation matrix sampled from the distribution described by the K- matrix, and a "smoothness" loss (Rudin et al.) 1992) is computed from the result, as described in Appendix B.3 (b) (Right) Left panel: original (unpermuted) example images. Center panel: the permuted versions. Right panel: these images after then applying the permutation recovered by the K-matrix. The K-matrix able to nearly unscramble the images into their unpermuted versions.
3.3 SPEEDING UP INFERENCE
We evaluate the inference speed benefit of using K-matrices real language translation model. We choose the state-of-the-art DynamicConv Transformer translation model (Wu et al., 2019), which offers 20% inference speedup the standard Transformer model, and replace dense matrices in the decoder's 's linear layers with K-matrices, which leads to a further 36% inference speedup (Table
As outlined in Section 2.3 algorithm. We provide fast implementations of this algorithm in C++ and CUDA, with an interface to Py PyTorch (Paszke et al. 2017), and use this implementation in experiments.
K-matrices admit simple and fast On log n) matrix-vector multiplication
8

---

Published as a conference paper at ICLR 2020
Table 4: Inference speed on the IWSLT-14 German-English translation task (test set). Using K- matrices instead of dense matrices in the DynamicConv decoder linear layers results in 36% faster inference speed (measured on single-threaded CPU with batch size of and beam size of 1).
Model
# params
BLEU
Sentences/see
Tokens/sec
Transformer VVawwani et al.
2017
43M
34.4
3.0
66.4
DynamicConv Transtormer (Wu et al. 2019
39M
35.2
3.6
80.2
DynamicCon Transformer w/ K-matrices (ours)
30M
34.2
4.9
103.4
We use K-matrices to replace all the linear layers in the decoder of DynamicConv (since 90% of inference time is spent in the decoder). As shown in Table A the IWSLT-14 German-English translation task, this yields a 25% smaller model with 36% faster inference time on CPU, at the cost of 1.0 drop in BLEU score (Our model also nearly matches the state-of-the-ar BLEU performance of 2 years ago obtained by the Transformer model VVaswani et al. 2017). despite being over 60% faster for inference than the Transformer.) The majority (55%) of inference time is spent in matrix-vector multiplication; our implementation of K-matrix-vector multiplication is about 2 times faster than the optimized implementation of dense matrix-vector vector multiplication in the Intel MKL library. Direct comparisons of K K-matrix multiplication with this and other highly-optimized routines such as the FFT are further detailed Appendix C
CONCLUSION
We address the problem of having manually choose among the numerous classes of structured linear maps by proposing the universal (expressive, efficient, and learnable) family of kaleidoscope matrices. We prove that K-matrices can represent any structured linear maps with near-optimal space and time complexity. Empirical validations suggest that K K-matrices are a promising and flexible way employ structure in modern ML; they can be used reduce the need for hand-engineering, capture challenging latent structure, and improve efficiency in models. We are excited about future work on further pendware-optimizz implementations of K-matrices, fully realize the size and speed benefits of structured matrices on a broad array of real-world applications.
ACKNOWLEDGMENTS
We thank Avner May and Jian Zhang for their helpful feedback.
We gratefully acknowledge the support of DARPA under Nos. FA87501720095 (D3M), FA86501827865 (SDH), and FA86501827882 (ASED); NIH under No. U54EB020405 (Mobilize). NSF under Nos. CCF1763315 (Beyond Sparsity), CCF1563078 (Volume Velocity), and 1937301 (RTML); ONR under No. N00014177 2266 (Unifying Weak Supervision); the Moore Foundation, NXP, Xilinx. LETI-CEA, Intel, IBM, Microsoft. NEC, Toshiba, TSMC, ARM, Hitachi, BASF, Ac- centure, Ericsson, Qualcomm, Analog Devices, the Okawa Foundation, American Family Insurance, Google Cloud, Swiss Re, and members of the Stanford DAWN project: Teradata, Facebook. Google, Ant Financial, NEC, VMWare, and Infosys. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views, policies, or endorsements, either expressed or implied, of DARPA, NIH, ONR, or the U.S. Government. Matthew Eichhorn and Atri Rudra's s research is supported by NSF grant CCF-1163481.
REFERENCES
Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks, In International Conference Machine Learning, pp. 1 1120-1122 1128, 2016.
Shaojie Bai, J. Zico Kolter, and Vladlen Koltun. An empirical evaluation of generic convolutional 2018.
and recurrent networks for sequence modeling. arXiv preprint
BL EU score is measure of translation quality; higher hetter.
9

---

Published as a conference paper at ICLR 2020
Peter L. Bartlett, Vitaly Maiorov, and Ron Meir. Almost linear VC dimension bounds for piecewise polynomial networks. In Advances in Neural Information Processing Systems, pp. 190-196, 1999.
Peter Bürgisser, Michael Clausen, and Mohammad A. Shokrollahi. Algebraic complexity theory, volume 315. Springer Science & Business Media, 2013.
Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. arXiv preprint arXiv: 1406. 1078, 2014.
Krzysztof Choromanski, Mark Rowland, Wenyu Chen, and Adrian Weller. Unifying orthogonal Monte Carlo methods. In International Conference on Machine Learning, pp. 1203-1212, 2019.
Ronan Collobert, Christian Puhrsch, and Gabriel Synnaeve. WavtLetter: an end-to-end ConvNet- based speech recognition system. arXiv preprint arXiv:1609.03193 2016.
James W. Cooley, Peter A. W. Lewis, and Peter D. Welch. The fast fourier transform and its applications. IEEE Transactions on Education, 12(1). 1969.
Tri Dao, Albert Gu, Matthew Eichhorn, Atri Rudra, and Christopher Ré. Learning fast algorithms for linear transforms using butterfly factorizations. In The International Conference on Machine Learning (ICML), 2019.
Christopher De Sa, Albert Gu, Rohan Puttagunta, Christopher Ré, and Atri Rudra. A two-pronged progress in structured dense matrix vector multiplication. In Proceedings of the Twenty-Ninle Annual ACM-SIAM Symposium Discrete Algorithms, pp. 1060-1079. SIAM, 2018.
Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. Xiv preprint 19Xiv:1907.048400 2019.
J. R. Driscoll, D. M. Healy, Jr., and D. N. Rockmore. Fast discrete polynomial transforms with applications data analysis for distance transitive graphs. SIAM Comput., 26(4):1066-109 August 1997. ISSN 0097-5397. doi: 10.1 (0.11777/0009533992222023
doi
Utku Evci, Trevor Gale, Jacob Menick, Pablo Castro, and Erich Elsen. Rigging the lottery: Making all tickets winners. arXiv preprint 1eXivv/911..1 134, 2019.
Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations (ICLR), 2019.
Hormozd Gahvari, Mark Hoemmen, James Demmel, and Katherine Yelick. Benchmarking sparse matrix-vector multiply in five minutes. In SPEC Benchmark Workshop, 2007.
John S. Garofolo, Lori Lamel, William M. Fisher, Jonathan G. Fiscus, David S. Pallett, Nancy L. Dahlgren, and Victor Zue. TIMIT acoustic-phoneti continuous speech corpus LDC93S1. Web Download. Philadelphia: Linguistic Data Consortium, 1993.
Pegah Ghahremani, Vimal Manohar, Daniel Povey, and Sanjeev Khudanpur. Acoustic modelling from the signal domain using CNNs. Interspeech, pp. 3434 3438, 2016.
Robert M. Gray. Toeplitz and circulant matrices: A review. Foundations and Trends in Communi- cations and Information Theory, 2(3):155-239, 2006.
Scott Gray, Alec Radford, and Diederik P. Kingma. GPU kernels for block-sparse weights. arXiv preprint arXiv:1711.0922 2017.
Jiuxiang Gu, Zhenhua Wang, Jason Kuen, Lianyang Ma, Amir Shahroudy, Bing Shuai, Ting Liu, Xingxing Wang, Li Wang, Gang Wang, Jianfei Cai, and Tsuhan Chen. Recent advances in convolutional neural networks. Pattern Recognition, 77:354-377, 2018.
Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In International Conference on Learning Representations (ICI.), 2016.
10

---

Published as a conference paper at ICLR 2020
Fredric J. Harris. On the use of windows for harmonic analysis with the discrete fourier transform. In Proceedings of the IEEE, 1978.
Nick Harvey, Christopher Liaw, and Abbas Mehrabian. Nearly-tight VC-dimension bounds for piecewise linear neural networks. In Saryen Kale and Ohad Shamir (eds.), Proceedings the 2017 Conference on Learning Theory, volume 65 of Proceedings of Machine Learning Research, pp. 1064 1068, Amsterdam, Netherlands, 07-10 Jul 2017. PMLR. URL http: http:::/ppocccccinggggooooooo/et m1r. m.r. wtt.ppe///////aeeeellll.. htm
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
David Helmbold and Manfred K. Warmuth. Learning permutations with exponential weights. Journal of Machine Learning Research, 10(Jul): 1736, 2009.
Alston S. Householder. Unitary triangularizatioon of nonsymmetric matrix. J. J.M,, org
October 1958. ISSN 0004-5411, doi: 10. (0.1145/200911332947
10. 00.11455320941..0 320947
Li Jing, Yichen Shen, Tena Dubcek, John Peurifoy, Scott Skirlo, Yann LeCun. Max Tegmark, and Marin Soljačić. Tunable efficient unitary neural networks (eunn) and their application to mnns. In Proceedings of the 34th International Conference on Machine Learning- Volume 70, pp. 1733-1741. JMLR. org, 2017.
Dan Jurafsky and James H. Martin. Speech and language processing, volume 3. Pearson London, 2014.
Thomas Kailath, Sun-Yuan Kung, and Martin Morf. Displacement ranks of matrices and linear equations. Journal of Mathematical Analysis and Applications, 68(2):395-407, 1979.
Donald Ervin Knuth. The art of computer programming, Volume 3: Sorting and Searching. Pearson Education, 1997.
Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolu- tional neural networks. In Advances in Neural Information Processing Systems, pp. 1097-1105, 2012.
Quoe Le, Tamás Sarlós, and Alexander Smola. Fastfood-computing hilbert space expansions in loglinear time. In International Conference on Machine Learning, pp. 244-252, 2013.
Quoc V. Le, Navdeep Jaitly, and Geoffrey E. Hinton. A simple way to initialize recurrent networks of 2015.
rectified linear units. arXiv preprint
Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-basedd approach to hyperparameter optimization. The Journal of Machine Learning Research, 18()):676566816 2017.
Yingzhou Li, Haizhao Yang, Eileen R. Martin, Kenneth Ho, and Lexing Ying. Butterfly factoriza- tion. Multiscale Modeling & Simulation, 3(2):714-732. 2015.
Yingzhou Li, Haizhao Yang, and Lexing Ying. Multidimensional butterfly factorization. Applied and Computational Harmonic Analysis, 44(3):737-758, 2018.
Fu-Hua Liu, Richard M. Stern. Xuedong Huang, and Alejandro Acero. Efficient cepstral normal- ization for robust speech recognition. In ARPA Workshop on Human Language Technology. 1993.
Jiancheng Lyu, Shuai Zhang, Yingyong Qi, and Jack Xin. Autoshufflenet: Learning permutation matrices via an exact lipschitz continuous penalty deep convolutional neural networks. arXiv preprint arXiv:1901.0866
2019.
J. Makhoul. A fast cosine transform in and two dimensions. IEEE Transactions on Acoustics, Speech, and Signal Processing, 28(1):27-33) February 1980. ISSN 0096-3518, doi: 10.1109/ TASSP. 1980. 1163511.
11

---

Published as a conference paper at ICLR 2020
Michael Mathieu and Yann LeCun. Fast approximation of rotations and Hessians matrices. arXiv preprint arXiv:1404. 7195, 2014.
Gonzalo Mena, David Belanger, Scott Linderman, and Jasper Snoek. Learning latent permutations
with Gumbel-Sinkhorn networks. In International Conference on Learning Representations, 2018.
URL httttt:t//ppenreeeeee
net forum? 1d=Byt DW
Zakaria Mhammedi, Andrew Hellicar, Ashfaqur Rahman, and James Bailey. Efficient orthogonal
parametrisation of recurrent neural networks using householder reflections. In Proceedings the 34th International Conference on Machine Learning- Volume 70, pp. 2401-2409. JMLR. org, 2017.
Decebal C. Mocanu, Elena Mocanu, Peter Stone, Phuong H. Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature Communications, 9, 2018.
Marcin Moczulski, Misha Denil, Jeremy Appleyard, and Nando de Freitas. ACDC: structured efficient linear layer. In International Conference on Learning Representations, 2016.
Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. In The International Conference Machine Learning (ICML), 2019.
Marina Munkhoeva, Yermek Kapushev, Evgeny Burnaev, and Ivan Oseledets. Quadrature-basee features for kernel approximation. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa- Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 9165-9174. Curran Associates, Inc., 2018.
Vadim Olshevsky and Mohammad Amin Shokrollahi. Matrix-vector product for confluent Cauchy- like matrices with application to confluent rational interpolation. In Proceedings of the Thirty- Second Annual ACM Symposium on Theory of Computing, May 21-23, 2000, Portland, OR, USA, /ttgg/10.. 1145/
pp. 573 581, 2000. doi: 10.1145/335305.33555 335305 335380
URL /doi..oooooooo acm. /
Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-IILT 2019: Demonstrations, 2019.
Dimitri Palaz, Ronan Collobert, and Mathew Magimai-Doss Estimating phoneme class conditional probabilities from raw speech signal using convolutional neural networks. In Interspeech, 2013.
Kuldip Paliwal. On the use of filter-bank energies features for robust speech recognition. In International Symposium on Signal Processing and its Applications (ISSPA), 1999.
Victor Y. Pan. Structured Matrices and Polynomials: Unified Superfast Algorithms. Springer-Verlag New York, Inc., New York, NY, USA, 2001. ISBN 0-8176-4240-4.
Victor M. Panaretos and Shahin Tavakoli. Fourier analysis of stationary time series in function space. The Annals of Statistics, 4 41(2):568-600 2013.
D. Stott Parker. Random butterfly transformations with applications in computational linear algebra. Technical report, UCLA, 1995.
Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang. Zachary Viti,o, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In Advances Neural Information Processing Systems (NeurIPS)- Autoddif Workshop, 2017.
Daniel Povey, Arnab Ghoshal, Gilles Boulianne, Lukas Burget, Ondrej Glembek, Nagendra Goel, Mirko Hannemann, Petr Motlickk, Yanmin Qian, Petr Schwarz, Jan Silovsky, Georg Stemmer, and Karel Vesely. The kaldi speech recognition toolkit. In IEEE 2011 Workshop on Automatic Speech Recognition and Understanding. IEEE Signal Processing Society, 2011.
Mirco Ravanelli and Yoshua Bengio. Speaker recognition from raw waveform with sincnet. In IEEE Workshop Spoken Language Technology, 2018
12

---

Published as a conference paper at ICLR 2020
Mirco Ravanelli, Philemon Brakel, Maurizio Omologo, and Yoshua Bengio. Light gated recur- rent units for speech recognition. In IEEE Transactions on Emerging Topics Computational Intelligence, volume 2, pp.
Mirco Ravanelli, Titouan Parcollet, and Yoshua Bengio. The toolkit. In IEEE International Conference Acoustics, Speech, and Signal Processing (ICASSP), 2019.
Pa PyTorch-Kaae speech recognition
Vladimir Rokhlin and Mark Tygert. Fast algorithms for spherical harmonic expansions. SIAM Journal on Scientific Computing, 27(6):1903-199) 2006.
Leonid I. Rudin, Stanley Osher, and Emad Fatemi. Nonlinear total variation based noise removal algorithms. Physica D: nonlinear phenomena, 60(1-4):259-266 1992.
Olga Russakovsky, Jia Deng. Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma. Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115 (3):211-255) 2015. doi: 10.1007/s1 1261--0--1----
Tara N. Sainath, Brian Kingsbury, Vikas Sindhwani, Ebru Arisoy, and Bhuvana Ramabhadran. Low- rank matrix factorization for deep neural network training with high-dimensional output targets. In Proceedings of the IEEE International Conference on Acoustics, Speech and Signal Processing, pp. 6655-6659. IEEE, 2013.
Tara N. Sainath, Ron J. Weiss, Andrew Senior, Kevin W. Wilson, and Oriol Vinyals. Learning the speech front-end with raw waveform CLDNNs. In Interspeech, 2015.
Roy Schwartz, Jesse Dodge, Noah A. Smith, and Oren Etzioni. Green AI. arXiv preprint 1rXxv:1907.105977 2019.
Vikas Sindhwani, Tara Sainath, and Sanjiv Kumar. Structured transforms for small-footprint deep learning. In Advances in Neural Information Processing Systems, pp.
2015.
S. S. Stevens, J. Volkmann, and E. B. Newman, A scale for the measurement of the psychological magnitude pitch. Journal of the Acoustic Society of America, 8(3), 1937.
G. Szegö. Orthogonal Polynomials. Number v. 23 in American Mathematical Society colloquium publications. American Mathematical Society, 1967. ISBN 9780821889527. URL https
google. com.
Anna T. Thomas, Albert Gu, Tri Dao, Atri Rudra, and Christopher Ré. Learning compressed transforms with low displacement rank. In Advances in Neural Information Processing Systems (NeurIPS), 2018.
Trieu H. Trinh, Andrew M Dai, Minh-Thang Luong, and Quoe V. Le. Learning longer-term depen- dencies RNNs with auxiliary losses. arXiv preprint arXiv: 1033:08033.0014,, 2018.
Joseph Tsidulko. Google showcases on-device artificial intelligence breakthroughs at I/O. CRN, 2019.
Mark Tygert. Fast algorithms for spherical harmonic expansions. ii Journal of Computational Physicx, 227(8))4260-4277 2008
Mark Tygert. Fast algorithms for spherical harmonic expansions, ini Journal of Computational Physics, 229(18):111--612,, 2010a.
Mark Tygert. Recurrence relations and fast algorithms. Applied and Computational Harmonic Analysis, 28(1):121-128, 2010b.
Aaron den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. WaveNet: A generative model for raw audio. arXiv preprint arXiv: 1609.03499 2016.
13

---

Published as a conference paper at ICLR 2020
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.
Scott Wisdom, Thomas Powers, John Hershey, Jonathan Le Roux, and Les Atlas. Full-capacity unitary recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 4880 4888, 2016.
Felix Wu, Angela Fan, Alexei Baevski, Yann N Dauphin, and Michael Auli. Pay less attention with lightweight and dynamic convolutions, In International Conference on Learning Representations (ICLR), 2019.
Saining Xie, Ross Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. In Proceedings of the IEEE conference computer vision and pattern recognition, pp. 1492-1500, 2017.
Felix X. Yu, Sanjiv Kumar, Henry A. Rowley, and Shih-Fu Chang. Compact nonlinear maps and circulant extensions. CoRR, abs/1503.03893 2015.
Felix Yu, Ananda Suresh, Krzysztof Choromanski, Daniel Holtmann and Sanjiv Kumar. Orthogonal random features. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 1975-1983. Curran Associates, Inc., 2016.
Xiyu Yu, Tongliang Liu, Xinchao Wang, and Dacheng Tao. On compressing deep models by low rank and sparse decomposition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
Neil Zeghidour, Nicolas Usunier, lasonas Kokkinos, Thomas Schatz, Gabriel Synnaeve, and Em- manuel Dupoux. Learning filterbanks from raw speech for phone recognition. In IEEE International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2018.
Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In Proceedings of the IEEE Conference Computer Vision and Pattern Recognition, pp. 6848-6856, 2018.
Ritchie Zhao, Yuwei Hu, Jordan Dotzel, Christopher De Sa, and Zhiru Zhang. Building efficient deep neural networks with unitary group convolutions. In Proceedings the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1300--1331, 2019.
Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. Xiviv preprint arX1v:1710.01878, 2017.
14

---

Published as a conference paper at ICLR 2020
A RELATED WORK
A.1 STRUCTURED MATRICES IN MACHINE LEARNING
Structured linear maps such as the DFT, the Hadamard transform and convolution are a workhorse of machine learning, with diverse applications including data preprocessing, random projection, featurization, and model compression. For example, the DFT is a crucial step in the standard filter bank speech preprocessing pipeline (Jurafsky & Martin 2014). and is commonly used when dealing with time series data in general (Panaretos & Tavakoli 2013). Fast random projection and kernel approximation methods rely on the fast Hadamard transform (Le al. 2013 Yu et al. 2016) and convolution (Yu et al. 2015). and convolution is a critical component of modern image processing architectures (Krizhevsky et al. 2012) as well as being useful in speech recognition (Zeghidour al. 2018) and natural language processing (Wu et al. 2019). Large learnable classes of structured matrices such as Toeplitz- like matrices (Sindhwani et al. 2015) and low-displacement rank (LDR) matrices (Thomas et al. (0188) have been used for model compression. However, despite their theoretical speedup, these structured matrix classes lack efficient implementations, especially on GPUs. Therefore, their use has largely been confined to small models (e.g. single hidden layer neural nets) and small datasets (e.g. CIFAR-10).
Butterfly matrices encode the recursive and--que structure of the fast Fourier transform (FFT) algorithm. They were first used in numerical linear algebra for fast preconditioning (Parker 1995). The butterfly factorization is then generalized encompass complementary low-rank matrices commonly encountered in solving differential and integral equations (Rokhlin & Tygert 2006 Tygert 2008: 2010b a. Li et al. 2015 2018). In machine learning, butterfly matrices have been use to approximate the Hessian for fast optimization (Mathieu & LeCun (0014). and to perform fast random
projection (Ting et al. 2017, Munkhoeva et al. [0118] Choromanski et al. 2019). Dao et al. (2019) show that butterfly matrices can be used to learn fast algorithms for discrete transforms such as the Fourier transform, cosine/sine transform, Hadamard transform, and convolution.
A.2 SPARSE MATRICES
Several classes of structured linear transforms are ubiquitous in modern deep learning architectures; particularly widespread examples include convolution and multiheaded attention. Recently, attempts to impose sparsity on the neural network weights have been gaining traction. State-of-the art approaches of this type typically accomplish this by pruning small weights (either gradually during training (Zhu & Gupta. 2017). or post-training (Han et al. 2016)) or by training a dense network and then identifying "winning lottery tickets" spprse subnetworks which may then be retrained from scratch with appropriate initialization (Frankle & Carbin 2019). Importantly, these approaches start from a dense network, and therefore training is expensive. There is also a more nascent line of work that aims to train unstructured sparse neural networks directly (Mocanu et al. 2018 Mostafa Wang 2019 Dettmers & Zettlemoyer, 2019 Evei et al., [2019). These approaches maintain a constant network sparsity level throughout training, and use heuristics to evolve the sparsity pattern during training. One drawback is that the indices of the nonzero entries need to be stored in addition to the entry values themselves, which increases the memory required to store the sparse weight tensors. Another drawback is that these approaches to learn the sparsity pattern are based on intricate heuristics, which can be brittle. We note that these heuristic sparsification techniques could potentially be combined with our approach, to further sparsify the K-matrix factors.
A.3 SPEECH RECOGNITION FROM RAW AUDIO
Numerous works focus on the problem of speech recognition from raw audio input, i.c. without manual featurization. SincNet (Ravanelli & Bengio 2018) a CNN-based architecture parameterized with sinc functions, designed so that the first convolutional layer imitates a band-pass filter. Zeghidour cct al. (2018) formulate a learnable version of a filter bank featurization; their filters are initialized as an approximation of MFSC features and then fine-tuned jointly with the rest of the model. Sainath et al. (2015) proposed a powerful combined convolutional LSTM (CLDNN)- model for learning from raw audio, using a large amount of training data. The WaveNet generative architecture (van den Oord et al., 2016), based on dilated convolutions, has been adapted to speech recognition and can be trained on raw audio. Other approaches that can learn from audio can be found in (Palaz et al.
15

---

Published as a conference paper at ICLR 2020
2013
Collobert et al. 2016 Ghahremani al. 2016). To our knowledge, the 14.6% PER achieved by our kaleidoscope LSTM model on the TIMIT test set is the lowest error rate obtained by a model trained directly the raw audio.
A.4 LEARNING PERMUTATIONS
Permutation matrices find use in tasks such as matching and sorting (among many others). Techniques to obtain posterior distributions over permutations have been developed, such as the exponential weights algorithm (Helmbold & Warmuth, 2009) and the Gumbel-Sinkhorn network (Mena et al. 2018).
Classifying images with permuted pixels is standard task to benchmark the ability of RNNs to learn long range dependencies. [Le al. (2015) propose the Permuted MNIST task, which the model has to classify digit images with all the pixels permuted. Many new RNN architectures, with unitary or orthogonal weight matrices to avoid gradient explosion or vanishing. have been proposed and tested on this task (Le et al.) 2 Arjovsky et al. 2016 Wisdom et al. 2016 Mhammedi et al. 2017 Trinh et al.) 2018). Standard gated RNN architectures such as LSTM and GRU have also been found to be competitive with these new RNN architectures on this task (Bai et al. 2018).
B ADDITIONAL EXPERIMENTAL DETAILS
B.1 SPEECH PREPROCESSING
In this section, we fully describe our settings and procedures for the speech preprocessing experiments in Section 3.1.I and present additional auxiliary baselines and results.
B.1.1 EXPERIMENTAL SETUP
We evaluate our speech recognition models on the TIMIT speech corpus (Garofolo et al. 1993), standard benchmark for speech recognition. The input is audio (16-bit, 16 kHz .wav format), and the target is the transcription into sequence of phonemes (units of spoken sound). Our evaluation metric the phoneme error rate (PER) between the true phoneme sequence and the phoneme sequence predicted by model. We use PyTorch (Paszke et al.) 2017). the Kaldi speech recognition toolkit (Povey et af.) (211), , and the Py Kaldi toolkit (Ravanelli et al. (019) for developing Py PoToch speech recognition models for all our experiments and evaluations.
B.1.2 MODEL AND EVALUATION
Our baseline Bi-LSTM architecture is taken from the Py PyTorch-Koe Kaldi repository This is strong baseline model that, the best of our knowledge, matches tatt--of-the-rr performance for models that use single type of input featurization (Ravanelli et al.) 2019). The original Bi-LSTM model takes as input filter bank features. These are computed as follows: (i) the waveform is framed (split into chunks of 25 ms each that overlap by 10 ms each), (ii) the waveform is dithered (zero-mean Gaussian random noise added), (iii) pre-emphasis is applied to amplify high frequencies, (iv) the Hamming window function (Hariss 1978) is applied. (v) the FFT is applied, and the power spectrum of the resulting complex-valuese output is computed, (vi) the power spectrum (which has dimension 512) is mapped to the "mel scale" (which is scale intended to mimic human auditory perception (Stevens et al.) 1937)) by multiplication with a specific banded matrix of dimension 512 x 23, and the entrywise logarithm of the output taken (the 23 outputs are called the filters), and (vii) cepstral mean and variance normalization (Liu et al. 1993) is applied. Numerical hyperparameters of this procedure include the dither noise scale, the pre-en pre-emphasis coefficient, the Hamming window size, the defaults.
number of mel filters, and more; we kept all these the same as the Kaldi/Py AaddiPPyTorc--
In contrast, our "K-matrix version" of the model takes as input the raw waveform, split into chunks the same way before but with no normalization, dithering, or other preprocessing, which is then fed into a complex-valleeee kaleidoscope [[BB*)²] matrix. Similarly the nonlinear steps computing filter bank features, the logarithm of the power spectrum of the output (which has dimension 512)
6This open-source
repository can be found at
com wwt.//avvamme11.i..m.mmm
pytorch-kaldi
16

---

Published as a conference paper at ICLR 2020
is then computed. This output is fed into the Bi-LSTM; the Bi-LSTM and kaleidoscope layer trained together in standard end-to-end fashion. The Bi-LSTM architecture is not modified aside from changing the imput dimension from 23 to 512; this (along with the z 75K parameters in the kaleidoscope layer itself) results in approximately a 1.1M increase in the total number of parameters compared the model that takes in MFSC features (a modest 8% relative increase). Total training time for our kaleidoscope-base MFSC features, not counting the time required to precompute the MFSC features; the FLOPs for inference-time time are approximately 15% greater (mostly due to the larger dimension of the input to the Bi-LSTM; the kaleidoscope layer accounts for less than 0.5% of the total FLOPs).
architecture is 7% greater than that required for the model that uses
As baselines, we also compare to inserting other types of linear transformations before the Bi-LSTM: fixed linear transformations (such as the fixed FFT, or no transform at all [i.e. the identity]), other train- able structured layers (low-rank, circulant, and sparse [using the sparse training algorithm of Dettmerss & Zettlemoyer (2019]]), and trainable unstructured (dense) linear layer. The kaleidoscope layer performs the best out of all such approaches. The fact that it outperforms even a dense linear layer with more parameters is particularly notable, as it suggests that the structural bias imposed by the K-matrix representation is beneficial for performance on this task. Full results given in Table 5
Table 5: TIMIT phoneme error rate (PER%, + standard deviation across 5 random seeds).
Model
Test set PER%
# Parameters
Low rank + LSTM
23.6 + 0.9
15.5M
Sparse + LSTM
21.7 0.9
15.5M
Circulant + LSTM
23.9 + 0.9
15,4M
Dense + LSTM
15.4 0.6
15.9M
FFT LSTM
15.7 - 0.1
15.4M
Identity + LSTM
20.7 0.3
15,4M
Kaleidoscope LSTM
14.6 - 0.3
15,4M
MFSC features + LSTM
14.2 + 0.2
14.3M
SincNet
Ravanelli et al. 2019)
17.2
10.0M
LiGRU Ravanelli al. 2018)
13.8
12.3M
In our experiments, we grid search the initial learning rate for the "preprocessing layer" (if applicable) in (5e-5, lc-4, 2c-4, 4e-4, 8c-4, 1. 1.6e-3), and fix all other hyperparameters (including the initial learning rates for the other parts of the network) to their default values in the PyTorch-Kald repository. The model and any preprocessing layers are trained end-to-end with the RMSProp optimizer for 24 epochs (as per the defaults the best preprocessing learning rate, while the final error rates are reported on the separate held-out test set. For all structured matrix baselines except circulant (which always has n parameters for an matrix), the number of parameters in the structured matrices is set equal the number of parameters in the butterfly layer, while the unconstrained matrix is simply a standard dense complex- valued square matrix. For all experiments with trainable "preprocessing layer," we initialize the preprocessing matrix to represent the FFT (or approximate it as closely as possible fi.e. minimize the Frobenius error to the true FFT matrix], in the case of low-rank, sparse, and circulant), which we found to outperform random initialization.
Torch-Kaldd), For each model, we use the validation set to select
B.1.3 EXTENSION: COMBINING MESC AND KALEIDOSCOPE
As an additional experiment, we sought to investigate whether combining the hand land-engineered MFSC featurization pipeline and learnable kalcidoscope layer (instead of replacing the former with the latter) could lead to accuracy gains. Specifically, this experiment we first used the standard filter bank featurization pipeline described above, and trained end-to-end as usual. Then, we replaced the FFT step with a K-matrix initialized to the FFT, and made the weights of the Hamming window function and the mel filter bank matrix learnable well (similarly to (Zeghidour et al., 2018)). We fine-tuned the resulting architecture for an additional 10 epochs. The final test PER% attained by this "hybrid" model is 14.0 + 0.3; the model has 14.4M parameters- negligible increase over the 14.3M in the original architecture. Thus, by combining the manually encoded domain knowledge in the filter bank featurization and allowing this structure to be learnable rather than fixed, able
17

---

Published as a conference paper at ICLR 2020
to nearly match the state-of offtee-----h-rrttt 13.8% accuracy TIMIT While this "hybrid" model certainly involves some band-engineering, the state-of-the-arr results use a concatenation three different speech audio featurizations MattraatttionsMMCCC.CM.C MFCC, and fMLLR as the neural network imput, along with customized RNN architecture (LiGRU) specifically designed for speech recognition, and thus require more complicated pipeline that is arguably even more hand-crafted.
B.2 REPLACING CNN CHANNEL SIIUFFLE
B.2.1 MODEL ARCHITECTURES
ShuffleNet is convolutional neural network with residual (skip) connections that uses permutation matrix to shuffle the channels after each grouped 1x1 convolution, sending the i-th channel the (i mod g)-th group, where is the total number of groups. The architecture for each residual block ShuffleNet is: 1x1 group conv -> Batch norm, ReI.U -> Permutation -> 3x3 depthwise conv >> Batch norm + Ixl group conv. The permutation is fixed.
Zhao et al. 2019) propose to instead use the Hadamard transform before and after each grouped Ixl convolution to mix the channels. Note that the Hadamard transforms are placed before the batch normalization and ReLU layer (unlike the permutation matrix in the original ShuffleNet design). In particular, the architecture for each block is: Hadamard - 1x1 group - Hadamard + Batch norm, ReLU - 3x3 depthwise conv + Batch norm + 1x1 group conv. The Hadamard transform is fixed.
In our architecture, we use a kaleidoscope matrix in OBB (product of an orthogonal butterfly matrix, diagonal matrix, and the transpose of another butterfly matrix) before and after each grouped 1x1 convolution. We place the second K-matrix after the batch norm and ReLU, to more closely mimic the original ShuffleNet design. The structure for each block is: K-matrix - 1x1 group cony Batch norm, ReLU + K- K-matrix - 3x3 depthwise conv - Batch norm + Ixl group conv. The K-matrices are trained along with the rest of the network, rather than being fixed.
B.2.2 EXPERIMENTAL SETUP
We evaluate the CNN architectures on the image classification task of the standard ImageNet dataset (Russakovsky et al. 2015). We use the standard data augmentation, training, and evaluation pipeline as in (Xic et al. 7p. We train with SGD on GPUs for 90 epochs, with a total batch size of 2048 and initial learning rate 0.8. For the 1.0 ShuffleNet g8 architecture, size to 1792 to fit into GPU memory, and correspondingly linearly scale the initial learning rate to 0.7. Other hyperparameters (e.g. learning rate schedule, weight decay, etc.) are kept the same in the ShuffleNet paper (Zhang et al. 2018). We use the training script from NVIDIA's deep learning examples repository
reduce the total batch
B.2.3 ADDITIONAL. RESULTS
In Table we report top-5 classification accuracy on ImageNet, to complement the top-1 accuracies in Table
Table 6: Top-5 classification accuracy of ShuffleNet on ImageNet validation set. We report results for different network width multipliers (number of channels), and for different kinds of matrices used for channel mixing. Using learnable K-matrix in place of each fixed permutation (shuffle) or Hadamard matrix improves top-5 accuracy by up to 4.8%. Parameter counts are the same as in Table 2
Shuffle
Hadamard
Kaleidoscope (K.) K. vs. Shuffle
0.25 ShuffleNet g8
68.6%
68.4%
73.4%
+4.8%
0.5 ShuffleNet g8
79.9%
79.2%
81.7%
+ +1.8%
1.0 ShuffleNet g8
86.0%
85.8%
86.8%
+0.8%
C dlassiff fatii htt.:iaatttttnnnnanaeeeee on/NN50v1.5
18

---

Published as a conference paper at ICLR 2020
In each setting, the total training time of our K-matrix approach is within 20% of the total training time of vanilla ShuffleNet.
In Figure 4
plot the loss and accuracy the training set and validation set when train 1.0 ShuffleNet g8, with either a fixed permutation (Shuffle) or a K-matrix for channel shuffling. Even though each K-matrix is product of multiple (sparse) matrices, the model with K-matrices takes about the same number of training steps to converge as the baseline model does. One possible reason that we constrain the K-matrices to be orthogonal (Section 2.4 thus avoiding vanishing or exploding gradients.
Shuffie loss
70
Kaleidescspe train loes
Shuffle
Kaleldoscope
Top-1 curacyy
30
3-
20
Shuffle train top-1 accuracy
2-
Kaleidaccope train acturacy
Shuffl val
Kalsidoscope top accuracy
0 20
60
Epoch
Epoch
(a) Train and validation loss
(b) Train and validation accuracy
Figure 4: Loss and top-1 accuracy of 1.0 ShuffleNet g8 with either a fixed permutation (Shuffle) or K-matrix for channel shuffling. The K-matrix model takes about the same number of training steps to converge as does the baseline model.
B.3 LEARNING PERMUTATIONS
B.3.1 DATASET
The permuted CIFAR-I0 dataset constructed by applying fixed permutation every input. We choose to use the 2-D bit-reversal permutation i.... the bit reversal permutation on 32 elements is applied to the rows and the columns. This permutation was chosen because locality -estrty- if two indices i, j are close, they must differ in a lower-order bit, so that the bit-reversed indices i', are far. This makes a particularly challenging test case for architectures that rely on spatial locality such "vanilla" CNNs.
B.3.2 MODEL AND TRAINING
We describe the model architectures used in Section 3.1 (those reported in Table
Our model (K + CNN) The model represents fixed permutation P. parametrized as K- K-matrix. to learn to recover the true permutation, followed by a standard ResNet18 architecture (He et al. 2016). Because of the simple decomposable nature of the butterfly factors (Section 2.1 our parameterization easily extensible with additional techniques:
We constrain each butterfly factor matrix the K-matrix to be doubly-stochastic. For example, each 2 block in the butterfly factor matrix of block size 2 has the form 1
where E [0, 1]. We treat this block as a distribution over permutations, a a a
'The bit-reversal permutation reverses the order of the bits in the binary representation of the indices. For example, indices [0, I.... 7] with binary representations [000, 001, 111] are mapped to [000, 100, 111]. which corresponds 1,
19

---

Published as a conference paper at ICLR 2020
generating the identity : 0)
1
1 with probability a and the swap i 0
with probability
1 1-a. Butterfly factor matrices with larger block sizes constrained to be doubly-stochastic in a similar manner. In this way, a permutation sampled for each butterfly factor matrix, and these permutations are composed get the final permutation that is applied to the image.
(ii) For each minibatch, the examples Px: by applying permutation samples on the (permuted) inputs are fed into an additional unsupervised reconstruction loss
(Px) + (Pr) -
Pz) (Px)
Σ
USiJER
measuring total variation smoothness of the de-noised inputs. Such loss functions are often used in image denoising (Rudin et al. 1992). A final regularization loss was placed on the entropy of P. which was annealed over time encourage P to converge toward sharper doubly-stochastic matrix (in other words, a permutation).
The model is trained with just the reconstruction loss to convergence before the standard ResNet trained on top.
These techniques are applicable to the K-matrix as well as specialized methods for representing permutations such as Gumbel-Sinkhorn (Mena et al., 2018) and are important for recovering the true permutation. However, they are not applicable flexibility of K-matrices for representing generic structure despite not being specially tailored for this task. We also remark that other classes of structured linear maps such as low-rank, circulant, and so on, are even less suited to this task than dense matrices, they incapable of representing all permutations.
general linear layer, which showcases the
Baseline architectures
1. Fully connected (FC): This is a 3-layer MLP, with hidden size 1024 and ReLU nonlinearity in-between the fully connected layers.
2. Recurrent neural network (RNN): We use gated recurrent unit (GRU) model (Cho et al.. 2014), with hidden size 1024. Many RNN architectures have been proposed to capture long-range dependency on permuted image dataset such as Permuted MNIST (Arjovsky et al. (2116). Standard gated architectures such as LSTM and GRU have shown competitive performance on the Permuted MNIST dataset, and we choose GRU as a baseline since has been reported to slightly outperform LSTM (Bai et al. 2018).
3. CNN: We use the standard ResNet18 architecture, adapted smaller image size of the CIFAR-10 dataset (changing stride from 2 to 1 of the first convolutional layer, and removing max-pooling layer that follows).
4. Dense CNN: We add an additional linear layer (i.e. dense matrix) of size 1024 x 1024 before the ResNet18 8 architecture. This dense layer can in theory represent a permutation, but cannot benefit from the additional techniques described above.
5. Baseline CNN (unpermuted): We use the standard ResNet18 architecture applied to the unpermuted CIFAR-10 dataset.
All models are trained for 200 total epochs, with the Adam optimizer. We use the standard learning rate schedule and weight decay from Mostafa & Wang (2019). We use Hyperband (Li et al.) (017)) to tune other hyperparameters such as the initial learning rate and annealing temperature.
B.4 SPEEDING DYNAMICCONY'S S INFERENCE
B.4.1 MODEL ARCHITECTURE
We start with the DynamicCony Transformer architecture (Wu et al. 2019), which is a variant of the Transformer architecture /Vaswani et al. 2017) where the self-attention in each layer is replaced with light-weight DynamicCony module. We use the implementation from the Fairseq library(Ott et al.) 2019 with Py Torch version 1.2.
This library can he found attp:p::/ggtthbb..c/////tttt/e//
20

---

Published as a conference paper at ICLR 2020
The architecture of each layer of the decoder is: Linear - DynamicCony Linear - LayerNorm - Encoder-decoder attention - LayerNorm - Linear - ReLU + Linear + ReLU - LayerNorm. In every layer of the decoder, with a K-matrix from the B class (i.e. a butterfly matrix).
replace the dense weight matrix in each of the four Linear layers
B.4.2 TRAINING AND EVALUATION
The models are trained from scratch using the training script from the Fairseq repository, with the same hyperparameters (optimizer, learning rate, number of updates, etc.) used in the DynamicConv paper (Wu et al. 2019). We note that the DynamicConv model with K-matrices in the decoder trains slightly faster than the default DynamicConv model (both models are trained for 50,000 updates, which requires approximately 7% less time for the K- K-matrix model than for the default model).
To evaluate inference speed, we run the decoding script on the IWSLT-14 14 De-En test set in single- threaded mode on server Intel Xeon CPU E5-2690 v4 at 2.60GHz, and measure wall-clock time. The test set contains 6750 sentences, with 149241 tokens. Following Wu al. (2019), we set the batch size to 1 and beam size to I for this evaluation.
B.4.3 ADDITIONAL. COMPARISON WITH OTHER STRUCTURED MATRICES
We additionally compare the speed-quality tradeoff of K-matrices with other classes of structured matrices, when used to replace the fully-connected layers of DynamicCon''s decoder. We consider the following additional classes of structured matrices: low-rank, circulant, Toeplitz-like (Sindhwani jct al. 2015), ACDC (Moczulski et al. 2016). Fastfood (Le et al. 2013). and sparse. For classes with variable number of parameters (e.g. low-rank, sparse), we set the number of parameters to match that of K-matrices. For sparse matrices, besides the result for an ensemble of 10 models (the default setting in the Fairseq repository), also report the result for a single model, that could have faster inference time (since ausembllig//vverainng sparse matrices produces a less sparse matrix).
In Figure 5 we plot the tradeoff between translation quality (measured by BLEU score) and inference speed (sentences per second). Most classes structured matrices produce similar translation quality (between 34.1 and 34.4 BLEU score). K-matrices have the second fastest inference time, only 7% slower than low-rank matrices. We note that low-rank matrices benefit from very well-tuned BLAS routines (matrix-matrix multiplication). Even though our implementation of K-matrix multiplication is not yet highly optimized, it is already quite close to the speed of low-rank matrix multiplication at an equivalent parameter count.
C SPEED BENCHMARK AND IMPLEMENTATION DETAILS
Each K- K-matrix (for fixed width and expansion), has an Onn log n) matrix-vector multiplication algorithm: sequentially multiply the input vector with each of the sparse factors. Our implementation of this simple algorithm is surprisingly competitive with optimized subroutines, both on GPU (e.g. for training) and on CPU (e.g. for inference). In Figure 6 we compare the speed of multiplying by a K-matrix in class B (i.e. a butterfly matrix) against specialized implementation of the FFT. We normalize the speed by the speed of dense matrix-matrix multiply (on GPU) or dense matrix-vector multiply (on CPU). On GPU, with input sizes n 1024 and batch size 2048, the training time (forward and backward) of K-matrices matrix about 3x faster than dense matrix multiply (GEMM from cuBLAS). For inference on CPU, the kaleidoscope fast multiplication can be one or two orders of magnitude faster than GEMV. Over a range of matrix sizes, our implementation is within factor of 2-4x of specialized implementations of the FFT, highly optimized kernel.
Our implementation also memory-efficien In the forward pass through the Ologg n) sparse factors, we do not store the intermediate results, but recompute them during the backward pass. Therefore the activation memory required is (bm) for an input batch size of b.
D SYNTHETIC MATRIX RECOVERY
We directly validate Theorem on well-known types structured matrices used in machine learning. Given structured matrix M, attempt represent M as closely possible using K-matrices as
21

---

Published as a conference paper at ICLR 2020
Low-rank
5.0
Kaleidoscope
Circulant
Sentences/s
4.0
Dy DynamicConv
3.5
Sparse
Fastfood
Transformer spase (ensemble)
Toeplitz-like
2.5
ACDC
2.0
33.8
34.0
34.2
34.4
34.6
34.8
35.0
35.2
BLEU
Figure 5: Tradeoff between translation quality (measured by BLEU score) and inference speed (sentences per second). K-matrices have the second fastest inference speed, only 7% slower than low-rank matrices.
Speedup over dense multiply
Speedup over dense multiply
100
10
2
2
11
20
211
N
N
FFT
Kaleidoscope
FFT
Kaleldoscope
(a) Training (GPU)
(b) Inference (CPU)
Figure 6: Speedup FFT and Kaleidoscope against dense matrix matrix multiply (GEMM) for training. and against dense matrix-vector multiply (GEMV) for inference.
well as the standard classes of structured matrices: sparse and low-rank. In Table 7 we quantify the expressivity of each of these three methods, measured by their ability to approximate a range of different structures. Results for "global minimum" of kaleidoscope matrices are obtained from the theoretical expressiveness results in Section [and Section [ Low-rank and sparse approximation have closed form solutions: truncating the SVD and keeping the largest-magnitude entries, respectively. We also report the results using SGD for kalcidoscope matrices to validate that good approximation with K-matrices can be obtained even from standard first-order optimization algorithms. Even with imperfect optimization, kaleidoscope matrices still capture out-of-class target matrices better than low-rank and sparse matrices.
The target matrices kaleidoscope, low-rank, sparse, convolution (i.e. circulant matrices), Fast- food (Le et al.) 2013). and entrywise random IID Gaussian matrix (to show the typical magnitude of the emror). All target matrices M were randomly initialized such that 2 M] I.
22

---

Published as a conference paper at ICLR 2020
Table Expressiveness of different classes of structured matrices: Frobenius error of represent- ing common structured matrices (columns) of dimension 256 using three structured representations of matrices with adjustable numbers of parameters. (Left group: Target matrices the same class as the methods. Middle group: Target matrices with fixed number of parameters. Right: Random matrix to show typical scale of error.) Each method is allotted the same number of parameters, equal to log factor more than that of the target matrix. Low-rank and sparse matrices are unable to capture any structure outside their own class, while the minima for kaleidoscope matrices found via optimization better capture the actual structure for out-of-class targets better than the baselines.
Method
Target
Kaleidoscope
Low-rank
Sparse
Convolution
Fastfood
Random
Kaleidoscope
0,0
0.0
0.0
0.0
0.0
Global Min.
Low-rank
14.9
0.0
10.8
14.6
11.6
13.5
Sparse
11.7
12.2
0.0
13.1
7.1
14.1
With SGD
Kaleidoscope
0.0
0.01
8.0
0.0
5.1
14.5
To find kaleidoscope approximation with SGD, we used Hyperband to tune its learning rate (between 0.001 and 0.5).
E PROPERTIES OF THE BB* HIERARCHY
Here, we justify why the definitions in Section 2.2 give rise to a hierarchy. We first make some basic observations about the parameterization.
Observation E.1. An
matrix M BB* has 4n logn parameters.
Proof. M can be expressed as product of log butterfly factor matrices of size X n. Each of these factor matrices has parameters per row, for total of 2n parameters each. Hence, the total number of parameters is 4n log
Observation E.2. Let M be an n mafrix in (BB*)). Then, given an arbitrary vector of length n, we can compute Mv with Ownne log(ne)) field operations.
Proof. Since M (BB*) y Definition 2.4 and each E, is an en x en matrix in BB Therefore, to compute Mv, we can use associativity of matrix multiplication to multiply the vector by one of these matrices time.
decompose it SE, Eg... ET, where S is as given in
Since all of these factors are sparse, we use the naïve sparse matrix-vector multiplication algorithm (begin with 0-vector and perform the corresponding multiplication and addition for each nonzero matrix entry). S (and thus S") have n NNZ. Therefore, matrix-vector multiplication by S or S requires (n) operations, which is dominated by the butterfly matrix vector multiplication. Each E, can be further decomposed into 2 log( ne) matrices with at most 2ne non-zero entries each (by Observation F. Therefore, matrix vector multiplication by each E, requires O log(ne)). Since there such E,, require total of O log(ne)) operations.
Now, we are ready to show that our definition of classes (BB*)² ) forms natural hierarchy. First, we must argue that all matrices are contained within the hierarchy.
Lemma E.3. Let M an arbitrary n matrix. Then M E (BB*) (BB*)((n-2) (2n-2)
Proof. Corollary in Appendix K shows that any n matrix be written in the form M, ...M, M, "MM, M .. where M, M; are orthogonal butterfly matrices and M diagonal matrix. We can combine with M,, form another (possibly not orthogonal) butterfly matrix. This yields a decomposition of M as products of (possibly not orthogonal) butterfly matrices and their (conjugate) transposes, completing the proof.
Next, argue that, up certain point, this hierarchy is striet.
23

---

Published as a conference paper at ICLR 2020
Lemma E.4. For every fixed c 2 1, there is matrix M,, (with sufficiently large) such that M, E ) but M, & (BB*)..
Proof. Given c, fix n be power of such that 4 lngg x For sake of contradiction, assume
that every n x n matrix in yet1 is also in (BBB*). Let A be an arbitrary n x n. matrix. From Lemma E.3 A (25*)(2m-2) From our assumption, we can replace the first c + 1 BB" factors of with с (potentially different) BB' factors and still recover A. We can repeat this process until we are left with e 8B factors, implying that A E (BB*)s. From Observation E. we require 4en log n < n² (by our choice of n)) parameters to completely describe A. This is contradiction matrix, and therefore has n arbitrary parameters. Hence, there must be some n. X n matrix in (BBB)) that is not in (B
since A is arbitrary
F ARITHMETIC CIRCUITS IN BB" HIERARCHY
In this appendix, we prove our main theoretical result, namely, our ability to capture general trans- formations, expressed low-depth linear arithmetic circuits, in the BB hierarchy, This result is recorded in Theorem I
Theorem 1. Let M be an n x matrix such that matrix-vector multiplicatiin of M times an arbitrary vector can be represented as be a linear arithmetic circuit C comprised of gates (including inputs) and having depth d. Then, M (BB*) Yo(e)
To prove Theorem 1 we make use of the following two theorems.
Theorem 2. Let P be an n n permutation matrix (with a power 2).. Then P E BB"
Theorem 3. Let S be an n X n matrix of NNZ. Then S E (BB*)) 4
Theorem is proven in Appendix G and Theorem 3 is proven in Appendix
Proof of Theorem 7 We will represent C product of d matrices, each of size s' 8', where s' is the smallest power of 2 that is greater than or equal to
To introduce some notation, define Wi.... wa such that wp represents the number of gates in the k'th layer of C (note that = n + 2k=1 wx). Also, define ...... Za such that ž1 and zg Wk-1 + 7 (Zy, is the number of gates that have already been used by the time we get to layer k).
Let gi denote the i'th gate (and its output) of C (0 (0si<) s), defined such that:
U4
0 5 <
9. Lagg, + B.grs
n S i<s
where i, 22 are indices of gates in earlier layers.
For the k layer C, we define the s' matrix M, such that it performs the computations of the gates in that layer. Detine the i'th row of M2 to be:
T
0 i < 2
Ma :
a.e B,e
2b S < zb Wk
0
i 2 2 + wi
For any 0 k < d, let Vk be vector
0
We'd d like to argue that Va contains the outputs of all gates in C (i.e, the n values that make up Mv). To do this we argue, by induction on k that Vy is the vector whose first 2g41 entries go: S1..... -(2--1), 1). and whose remaining entries are 0. The base case, & = 0 is trivial. Assuming this holds for the case k 1, and consider multiplying V 1 by Mg. The first z rows of M, duplicate
24

---

Published as a conference paper at ICLR 2020
the first 2ς entries of Vk-1 The next wy rows perform the computation of gates ........ . 11-1) Finally, the remaining rows pad the output vector with zeros. Therefore, Vy is exactly as desired.
The final matrix product will contain all elements of the output. By left multiplying by some permutation matrix P. we can reorder this vector such that the first n entries are exactly Mv. Hence, are left to argue the position of PM....MMM M2M, within the B5 hierarchy. Each M, is matrix with total 2w² + 2 < 2s' NNZ. From Theorem 3 we can, therefore, represent M2 as a product of O(1) matrices (of size 2s') in BB From Theorem = (s).
P BB". Note that s < 2s, so
Our final decomposition will have O(d) BB* factors, and requires expansion from size size 28', or an expansion factor of )+)) Therefore, M E (BB*) )o(;)" as desired.
Remark F.1. By applying Observation E.2 we see that Theorem 7 gives an O s) matrix vector multiplication algorithm for M.
G PERMUTATIONS IN BB*
In this appendix, we prove Theorem addition, we will also show that permutations are in B* B, where the set 1" B is defined analogously to BB (i.e. matrices of the form M = M2M2 for some M, M2 E B).
To prove Theorem 2 we decompose permutation matrix P into P = LR, with L E B and R E B Throughout the proof, we make use the following definition.
Definition G.1. Let be an n X n permutation matrix (n a power of We say that L meets the 2 balance condition if L can be divided into chunks of 2 (with each chunk having all columns i such that | has the same value) such that for every 0 S m < 22 each chunk has exactly one L[; k] exy with Thk = m mod 23). We say that is modular- if meets the 2 balance condition for each 2 2
0
(0)
3
(3)
4
6
7
L
B
n
L
Figure 7: First step of decomposition of codular-balanced matrix L. Here, the red entries must be permuted into the main diagonal blocks.
Lemma G.1. Let L be an n x n modular-balanced matrix. Then B.
Proof. We proceed by induction on n. The base case 2 is trivial. As our inductive hypothesis, modular-balanced
z we assume that all modular- balanced matrices of size a x 2 are butterfly matrices of size " Definition 2.3 it is sufficient to show that L can be decomposed
2- From
L 0
L B
L2
L'
where B,, is butterfly factor of size and each Ly is 3 x z modullar-balanced matrix.
25

---

Published as a conference paper at ICLR 2020
Define L1 and Lg such that:
Li [i ] L[i,]]
L2
i
+L
2"
2.
2
Note that since L is permutation matrix (and thus has exactly one non-zero entry per column), at most one term of each of these sums can be non-zero.
For sake of contradiction, assume L1 is not modular-balancee Then, for some 2 < columns C such that S / and such that indices of the non-zero entries of L1 in columns C1 and 02 are the same modulo 2/. However, from the definition of L1. this implies that the indices of the non-zero entries L in columns ei and 02 are also same modulo 2 contradicting L being modular-balaneee
2 there are two
Hence, L1 is modular- modulat-balanced. An analogous argument (that instead considers 2 of L) shows that L2 is also moodllar-balancee
columns C1 + n C2 2 2
To complete the proof, modular-balanced, it is permutation matrix. Therefore, L/ has exactly non-zero entry in each of the first rows and columns from Lı and exactly 1 non-zero entry in each of the second y rows and columns from L2. Hence, L' is a permutation matrix. Since both and L' are permutation matrices, B = L (L') must also be permutation matrix. Therefore, we can view B as performing a permutation the rows of L' to get L.
must argue that B, is butterfly factor of size Since each L; is
Consider the i'th row of L', with 0 S <sc 3. There are two possible cases.
Case 1: : L|
In this case, the column of L with a non-zero entry in row is in the left columns. The column of with non-zero entry in row + 2 must, therefore, be in the right 3 columns, otherwise would not satisfy the z balance condition. Therefore, L' = = [it 4.:.. so we set d = B
[ + 3. i 3 1.
Case 2: L/ + =]
vL [i+ By the definition of L', = in row + must be in the left 2 columns. By the ž/2 balance condition of L, the column of L with non-zero entry in row must be in the right z columns. Therefore, L' : = L (t, :l. so we set
:. In this case, the column of L with a non-zero entry
B [ / B + c. 1.
In both cases, the the bands away). Hence, B is butterfly factor of size
entries of B fall into the correct diagonal bands (the main diagonal, and
Now, we consider the process of transforming P into a modular-balanced matrix. We make use of the following lemma.
5
2
G
P
B n
Figure 8: First step of balancing 8 8 bit reversal permutation (a component of the 8 8 DFT), Red signifies edges that must be flipped.
Lemma G.2. Let M be a k x ie matrix with non-zero entry per column, such that for each 0 < m < 2' there are exactly 2 columns with non-zero entry in row with index = m (mod k) Then, there butterfly factor By such that MB,- M', where M' meets the 7 balance condition.
26

---

Published as a conference paper at ICLR 2020
Proof. We construct directed graph G with nodes in [ For each 0
add directed
edge from node (s mod 5) to node (t mod ()) if M|; e, and M :, i e, Each node has (undirected) degree exactly 2 by the structure of M. Hence, G is union of disjoint (undirected) cycles.
If M met the è balance condition, then each node would additionally have in-degree exactly 1 and out-degree exactly By reversing edges of such that each (undirected) cycle becomes directed cycle, we can achieve this. However, reversing edges corresponds to swapping columns of M that are &/ apart. Let B3 be the permutation matrix that performs all such swaps. Bg has non-zero entries only along the main diagonal and the diagonal bands _ away, and thus is a butterfly factor of size k.
We are ready to present the decomposition of P.
Lemma G.3. Let P an n x n permutation matrix. Then we can decompose into P LR. where L is modular- ballace and R E B
Proof. We repeatedly apply Lemma G.2 First, we conclude that there is butterfly factor B, such that
PB = P
where P' meets the 2 balance condition. independently. We can again apply Lemma G.2 (twice) to conclude that there are butterfly factors such that
Now, we consider the first and last columns of P
B B Bgl2
PB,
[
[Bg]
0
(n PB
B
(n) a
P"
B
where p" meets the and z balance conditions.
We continue this process until we obtain a matrix that meets all of the balance conditions. Our final equation of the form:
P
B B m ... B (p)
PB L,
where B is butterfly matrix and L is modular balanced matrix. Let R == B B (since B is permutation matrix, and thus is orthogonal) and hence R B". Then P = LR, as desired.
Theorem follows immediately from Lemmas G.3 and G.1
We now show that permutations are also in B. We start with the relationship between butterfly matrices and the bit-reversal permutation.
Lemma G.4. Let Pbr be the x bit-reversal permutation matrix where is some power 2, 2, and let Mj E be an n X n butterfly matrix. Then there is some butterfly matrix M2 E B such that
M = Pb.
Proof sketch. For any input vector of length to perform Mix, we trace through log, n steps of the multiplication algorithm. At each step, we perform 2 x matrix multiplication on elements of x whose indices are n/2 apart (e.g. indices 0) and n/2, 1 and n//2 etc.), then n/4 apart, and so on, till indices are that apart. If we apply the bit-reversal permutation on x, then indices that n/2 apart will become 1 apart, indices that are n/4 apart will become apart, and so on. So the multiplication algorithm Mi equivalent to applying bit-reversal, then multiplying the permuted vector with another butterfly matrix (i.e. 2 x 2 matrix multiplication then 2 apart, and so on, till indices that are n1/2 apart). Finally we need to do another bit-reversal permutation to put all the indices back to the original order. If call this other butterfly matrix M2, then we have shown that Mix Pb, M.P.p b, x. This holds for all x (for the same matrix M2), so we have Mi- Pb, MrP br-
indices that are apart,
Remark G.5. Lemma G.4 explains the connection between the two most common fast Fourier transform algorithm, decimation in time and decimation in frequency. Using the decimation-in in--eee
27

---

Published as a conference paper at ICLR 2020
FFT, can write the DFT matrix F product of butterfty matrix M1 and the bit-reversal permutation (see Section
P, br
Taking conjugate transpose, we obtain F = Pt. M (recall that P is its own transpose/fnverse). On the other hand, F" just scaled version of the inverse DFT matrix, so apply Decimation-in-tune FFT to the inverse DFT,
wrile F M2Pbr br for some other butterfly matrix M2. Hence P = MrPbr, br, and thus PorMi = Mr (for these particular butterfly matrices M1 and M2). Note that this yields another decomposition of the DFT matrix, F M which is exactly the decimation iertattiooni---reuuee freeuuuyy FFT algorithm.
We are ready to show that permutations are in B B.
Lemma G.6. Let P be an n x n permutation matrix (with n a power 2). Then there are butterfly matrices M1, M2 B such that P M;M2.
Proof. Consider the permutation P P= Pt. PP.. By Theorem there are some butterfly matrices
M1, M2 E B such that P M, Applying Lemma G.4 we can replace M2 with Mr
for some butterfly matrix M2 B. We thus have:
PP = br br-
Pre- and post-multiply both sides by Phr (which is its own inverse):
P P P.
Applying Lemma G.4 again, we can replace P M,, with Mi for some butterfly matrix M1 E B.
Thus:
P MM..
H BB CLOSURE LEMMAS
Here, we present some basic facts of the BB hierarchy that will be useful for later constructions. For simplicity, assume (WLOG via O-padding) that all matrices are square matrices with size that is power of 2.
Lemma H.1. IfME E B (or M E B*), then DM, MD E B (B" resp.) for any diagonal matrix D.
Proof. Left multiplication by diagonal matrix scales the rows M by the corresponding diagonal entries. The same can be achieved by scaling all entries the leftmost butterfly factor matrix. Similarly, right multiplication by diagonal matrix scales the columns of M, which can be achieved by scaling all entries in the columns of the rightmost butterfly factor matrix.
Lemma H.2. Let A, E FAXD, A I and B E (BB*); y then AB (BB*) 20 +w1
Proof. Let EA. EB E genxen be defined such that SEAST, SE (with S as in Definition 2.4 Then
I 0
AB S
EA
EB ST
en X X em
I,
II 0
EA (BB*) w
EB (BB*)uz by Lemma H.l Hence, AB (BB*) un by
0 0
0 0
Definition
2.4
Lemma H.3. Let A A A Am E BExk If AI...., Am E (BB*). then Diag( A Ay...., Am) E (BB*) )222
28

---

Published as a conference paper at ICLR 2020
Proof. For each 1 - i I m, let EA, Fekxok be defined such that A;
SE (with S in
Definition 2.4h. Then
A
0
E 0
0
A2
0
E
0
SP
p"sT
0 E EA...
where is permutation that that moves the first k rows of each EA; (in order) into the top mk rows, From Theorem 2 P E BB*, (and so is pz also a permutation). Within the RHS block matrix, the decompositions of each EA, can be done in parallel, requiring total width w. Hence, (ong,,,,,,,AA E (BB**) ym+ ) as desired.
Remark H.4. If e = in Lemma H.3 then P is unnecessary, Hence, Diag( 1 Am) (BB*) ).
Lemma H.5. Let A.,..., Am be k x k matrices in (BB*). then Σ A; (BB*) mw
Proof. For each 1 < i m, let EA, E Fekxek be defined such that A; Definition 2.4p. Note that EA, E (BB*)". Consider matrices of the form:
SEA, S" (with S as in
Lek
EA.
0
0
Lek
0
0
Lek
0
0
ck
1 2ok
I 2nk
0
Lnb
0
L,k
0
T 2ec
0
0
0
0
0
EA:
0
0
Iek
1
0
0
0
Lek
R
M, E Flckxtek
S
P
Here, L and R. compute the sum of the 2ek x 2ek matrices on the diagonal of SP where P1 is permutation swapping Es; to the 4th ek-block column. Note that the diagonalization of four matrices in (BB*)* )d, so S E (BB*)" " by Remark H.4 In addition, since each block in S is butterfly matrix of size ek. only uses butterfly factors up to size ek, so the outer factor matrices sizes 4ek and 2ek in S are unused. Also note that L and R are butterfly factor matrices of size 4ek (or B (dek)) and P1 is a butterfly factor matrix of size 2ek (or B (4ck)) This allows us to fold the surrounding matrices L, Pi, R. into S, so M, (BB*)".
Through repeated application (m times) of the identity
I
A
I
B
I
A
+
B
0
I
we see that
L
Σ 1
E
0
Lek
0
0
M,
(2)
0
0
0
0
0
0
0
1=1
M E F den
From Lemma H.2 M E (BB*) yoaw Finally, note that > A,
SMP where P2 is
permutation that moves the first & columns of the second block-column of M the left. P can be folded into the final summation factor Mm as follows:
Lak
0
L
L
Teb
Tzck 1ock
L
0
0
L
0
0
I Teck
(3)
0
0
L
0
Lek
0
0
Lnk
0
I 2ank
Lek
0
0
Iek
0
I
R
R
P1
P2
P
Hence, m D
A; (BB*) as desired.
29

---

Published as a conference paper at ICLR 2020
Lemma H.6. Let M be an invertible X n matrix such that M E B. Then M B
Proof. We prove this in series of steps.
First, let B3 be an invertible butterfly factor of size Consider the method of computing B by performing Gaussian elimination on the matrix [By [ obtain the matrix [Ix|B By the form of B, non-zero entries within a row or column are always exactly 2 positions apart. Therefore, the only row operations needed for this Gaussian elimination are:
&
Scaling a row by a constant factor c + 0
Addition of row to another row exactly rows apart
Performing these operations I& will only allow non-zeros on the main diagonal and k away from the main diagonal. Hence, B is also butterfly factor of size k.
2 diagonals
Next, let ( be invertible butterfly factor matrix of size and block size k. Its inverse is the block diagonal matrix formed by the inverses of each of its constituent butterfly factors. From above,
B (n)
is also butterfly factor matrix of size and block size k.
Finally, consider M E
M
B m B (n) n
BBTa)
-1
=(B{")
-(B(a)) -
(B(-))
*B((1))
-1
-1 =By B (m)
B
(n)
B
Finally, we include closure result for Kronecker product, another common matrix composition operation. Although Lemma H.7 is not directly used in the subsequent proofs, it allows for examples the results for the DFT to be lifted to dimeeoodimensionall Fourier transforms. We also note that the
closure bound in Lemma H.7 can be tightened in such cases (cfRemark H.4).
Lemma H.7. Let A, FaXn, If A (BB*)a) and B (BB*) )e
"2 then A & B (BB*) "1 w
Proof. Note that
A 2 B (A II[ - PI A)P(I B),
for some permutation By Lemma
H.3 I A and I& in (BB* yr 1 (BB*)=**? respectively,
The result follows from combining with P E BB and Lemma H.2
I SPARSE MATRICES IN BB* HIERARCHY
this appendix, we prove Theorem First, we consider matrices with at most n NNZ.
Lemma 1.1. S be an n matrix with at most n NNZ. Then, (BB*)..
We use this lemma and the addition closure lemma to prove Theorem
Proof of Theorem 3 We note that any sparse matrix is the sum of matrices of at most NNZ and we appeal to Lemma H.5
In the rest of the section we will prove Lemma [.I We begin by defining two classes of matrices that will be used in our decomposition.
Definition L.. An 0 OSiSj < nt, if Hi + 0 and Hii .i) + O, then j' - j (3' -) mod n. An matrix V is vertical step matrix V* is horizontal step matrix.
matrix H is horizontal step matrix for every 0 i and
30

---

Published as a conference paper at ICLR 2020
With this definition, the horizontal step matrix obeys "Lipschitz-like -ike" condition. Each column of horizontal step matrix can have at most one non-zero entry, and given two non-zero columns & apart, the non-zero entry in the right column must be between 0 and k rows below the non-zero entry in the left column. Note that to show that matrix is a horizontal step matrix, is sufficient to argue that this condition holds for each pair of neighboring non-zero columns.
Similarly, each row of a vertical step matrix can have at most one non-zero entry, and given two non-zero rows apart, the non-zero entry in the lower row must be between 0 and & columns the right of the non-zero entry in the upper row.
Lemma 1.2. Let H be an n x n horizontal step matrix. Then H E B.
Proof. We proceed by induction on n. The base case 2 is trivial. As our inductive hypothesis, we assume that all horizontal step matrices of size y & are butterfly matrices size 2. From Definition 2.3 it is sufficient to show that H can be decomposed as:
Dr D
D2 H. D.
0 H₂
D. H D&H, D2H2
DaH,
H
(4)
where H1, H2 are " x horizontal step matrices and each D3 is 2 x 2 diagonal matrix. Denote the four, 2 x corner submatrices of H by:
H 12
H
Then, define Hi and H2 by:
Hi H1 + H21
H2 H12 H22
For sake of contradiction, assume that H2 is not horizontal step matrix. Then, there are 0 < i, n 0 S j & j' < such that H₃ [V * 0. Hi''',' * 0, and j' jj < (i' - mod n From our definition of H1, the non-zero entries in columns j and j' of H are either ((i mod 5) or ( (i' i) mod }), both of which are greater than j' - j. rows apart. This contradicts H being a horizontal step matrix. Hence, H₃ must horizontal step matrix, as must Hg from an analogous argument.
2-
Next, we define D,, D2, D3, D4 by:
[1
H21 [k:
{
H (k. = =0
D Di(kAK] k]
(0
D2[k, k]
otherwise
otherwise
[k,
Da[k, k] =
D.[kAA] =
otherwise.
otherwise.
To finish the proof, we argue the correctness of the decomposition by equating arbitrary entries of each of the 4 corner submatrices. We begin with the upper left submatrix.
4
D D,H, [i
Σ
D
Ai
[b.
by definition of matrix multiplication
k=
[i
Hi
H.
D is diagonal matrix by definition of D, and H.
[Hail:)) (H. + Hall(,)
Here, we consider two cases:
Case 1: H2 *
Since H is a horizontal step matrix (and hence may have at most one non-zero entry per column), follows that H [i 0. In this case, the indicator function evaluates 0, D H [i 0
Hn [i, j. as desired.
Case 2: Hap [i.
31

---

Published as a conference paper at ICLR 2020
If H [ 0, then D2H
Otherwise, for sake of contradiction, suppose that H [i * O. Then, two of the first 2 columns of H would have non-zern zero entries 2 rows apart, contradicting H being horizontal step matrix. Hence, [2i 0, so D H [ł, H [ j]. as desired.
= = = =
decomposition correctly recovers the upper left corner of H. Analogous arguments show that the other three corners are also correctly recovered. Hence, our decomposition is correct, and by induction, H B.
In all cases, H H
Corollary 1.3. Let V be vertical step matrix. Then V E B".
2
2
S
P1
S'
P3
2
V
P2
Figure 9: Decomposition x 4 sparse matrix into P, HP, VP3
Now, we use step matrices to prove Lemma
Proof of Lemma I.] Given decompose it H, VP3, where each Pa a permutation matrix. H is horizontal step matrix, and V is vertical step matrix. For an example of this, see Figure
We first decompose S as S = P,S'P3, where P1 is the permutation that moves all 0 rows of S to the bottom and P3 the permutation that moves all 0 columns of to the right.
Next, we further decompose S' into S' HV' as follows. Since S' has s S n NNZ, we can parameterize S' by = ((c,, (x) 0 k < 8) such that (' Ck. with the non-zero entries indexed in row-major order. Define matrix H by:
Ck eip O5k<s
H H kj
10
otherwise.
Define matrix V by:
eff O<k<s
[k :]
otherwise.
32

---

Published as a conference paper at ICLR 2020
To show that S' HV we consider an arbitrary entry:
HV HV =
H
[k
by definition of matrix multiplication
k=0
Σ k=0
Hli, kj Vikj
H is 0 in all but first columns
Σ ck 1=i 1==グ= k=0
by definition of H and V
Here, note that (i.j) equal (kk for most value of lo since the locations in are unique. Hence, HV = cs only (i,j) = (kk, ) for some k; which is exactly the definition of S'. Hence, S' HV
We argue that H a horizontal step matrix through a series of assertions. First, note that H has exactly one non-zero entry in each of its first s columns. Also, note that since 0 is in row-major order, these non-zero entries are sorted (any column to the right cannot have a non-zero entry in higher row). Hence, show that H horizontal step matrix, is sufficient to argue that adjacent columns of H have non-zero entries at most one row apart. This is equivalent to S' having no zero rows between two non-zero rows, which is guaranteed by P1. Hence, H a horizontal step matrix.
Since V' has at most one non-zero entry per row, we may permute the rows of V to obtain matrix V. where the non-zero entries of V are sorted (any lower row below cannot have a non-zero entry in an earlier column). Hence, for some permutation matrix (P2) V = (P2) V', which implies that V V. It has exactly one non-zero entry in each of its first columns. From the action of 22 these non zero entries are sorted. Therefore, by the same argument as for H above, V is a horizontal step matrix. Hence, V is vertical step matrix.
In all, we have found a decomposition $ = H,HP2 VP3. where each Ps is permutation matrix (E BB by Theorem 2 H is horizontal step matrix (e B by Lemma I.2 and V is vertical step matrix (E B by Corollary L3 Moreover, by Lemma G.6 P2 E B" so P2, V can be combined
obtain HP2V (BB*) Jz. By Lemma H.2 (B8*)4
Corollary 1.4. Let R be n n matrix of rank r. Then R E (B
Proof. We decompose R as R GH where G, H zero-padding, both of these can be made into n x n matrices with at most rn NNZ. The proof follows immediately from Theorem and Lemma H.2
matrices. With appropriate
J EXAMPLE OF K-MATRIX REPRESENTATION OF STRUCTURED MATRICES AND COMPARISON TO BP HIERARCHY
In this appendix, we show explicitly how some common structured matrices (e.g. originating from fast transforms) can be represented as K-matrices. We also draw comparisons between the BB hierarchy and the BP hierarchy introduced by Dao et al.) (2019).
Lemma J.1. Let F,, be the Discrete Fourier Transform of size n. Then F,, E (BB*)².
Proof. From Parker (195). we can express F, nt as F., =.. where B B and P is permutation (the bit reversal permutation). From Theorem 2 P E BB Hence, by Lemma H.2 F F, E (BB*)²
Lemma J.2. Let H1, be the Hadamard Transform of size n. Then H, BB"
Proof. H. B, so trivially H, BB"
Lemma J.3. Let S, be the Discrete Sine Transform of size Then S,, (BB*).
33

---

Published as a conference paper at ICLR 2020
Proof. As described in Makhoul (1880), S, can be performed scaled permutation (separating the even and odd indices of the input, and reversing and negating the odd indices) composed with Fn. Therefore, we may decompose S, S = B P2 D P1, where P1 and D a diagonal matrix. P2 D p is simply a permutation matrix with scaled entries, which can be equivalently expressed D' P' for some diagonal matrix D' and permutation P By Lemma H.1 B D' E BB By Theorem 2 P' E BB Hence, by Lemma H.2 S E (BB*)².
permutations, B B,
Remark J.4. An analogous argument shows that the Discrete Cosine Transform is also in (BB*)?.
Lemma J.5. Let Cn be an n n circulant (convolution) matrix. Then Cn E BBB.
Proof. Using Theorem 2.6.4 of Pan 2200 is the Discrete Fourier Transform and D is diagonal matrix. (F,,) -1
can express Cn as C.
(Fn) " DF, where F,, B P (with B E B, Pa
permutation), which implies that n (P) (B) Therefore
C B D (P) (B)
The middle three factors have the effect of performing permutation, scaling each element, and undoing the permutation, which is equivalent to simply scaling by some diagonal matrix D'. Hence, we are left with
C₁ = B DD)
By Lemma H.1 B D'E e B. By Lemma H.6
( E B Hence, Cn E BB
Remark J.6. We can expand any n x Toeplitz matrix T. into a 2n x 2n circulant matrix (with upper left submatrix equal to Tn). Hence, T, (BB*), by Lemma J.5
The Fastfood matrix class (Le et al. 2013 can be tightly captured the BB" hierarchy:
Lemma J.7. The product SHDPHB where S, D. B are diagonal matrices, H is the Hadamard transform, and permutation matrix, in (3
Proof. We have shown in Lemma J.2 that H E BB" and in Theorem 2 that P E BB* Since BB* is closed under diagonal multiplication (Lemma H.1). conclude that SHDPHB E (BB*)3. n
The two classes of matrices introduced in Moezulski al. (016)) called AFDF and ACDC, are also tightly captured in the 13" hierarchy:
Lemma J.8. Let D be product of diagonal matrix A, the inverse Fourier transform F-1 another diagonal matrix D, and the Fourier transform F. Then AF DF E BB*
Let DC be a product of a diagonal matrix A, the inverse cosine transform C-1 another diagonal matrix D, and the cosine transform C. Then AC-IDC E (BB*)..
Proof. We have argued in Lemma J.5 that F- DDF E BB', Since BB" is closed under diagonal multiplication (Lemma H we conclude that AF AF-IFF
DD E BB*
We have shown that C E (3 C-1 E (BB*)2 as well. Since BB is closed under diagonal multiplication (Lemma H.I. we conclude that DCC (BB+)4.
Remark J.9. Within each butterfly factor matrix of the DFT (excluding the bit reversal permutation) and the Hadamard transform, the columns are pairwise orthogonal and have norm Hence, we can divide all factors by /2 make orthogonal factor matrices. To counteract this scaling, we can add diagonal matrix with / ( / in all entries to the factorization. By doing this all of the above transforms in the OBB hierarchy (defined in Appendix K) with the same width and expansion factor.
place
34

---

Published as a conference paper at ICLR 2020
J.1. MULTI-DIMENSIONAL TRANSFORMS
Here, we show that, using larger matrices, we are able to similarly capture multi-dimeensioall versions of the above transforms.
Lemma J.10. Let F be the 2-dimensional Discrete Fourier Transform (represented as an n² x n? matrix). Then F E (BB*)².
Proof. The separation property of the 2-D DFT allows express its action the composition of a 1-D DFT on each of its rows and a 1-D DFT on each its columns. If we view the 2-D DFT as an n² n² matrix, its input and outputs will both be column vectors of size n². As our convention, we list the entries of the input vector in the row-major order corresponding to the n input matrix. Then, we consider the 2-D DFT in four steps, where the first two steps perform the 1-D DFT row-wise, and the second two steps perform the I-D DFT column- wise:
x matrix as
Step 1: Permute the columns:
We permute the columns (with a bit reversal permutation), which performs a bit reversal permutation on each row. Viewing the input as vector, this step corresponds left multiplication by a permutation matrix Pe that permutes the entries of each chunk of size n of the input vector. Step 2: Multiply each row by a butterfly matrix
Since the entries of the input were listed in row major order, this step is achieved through multiplication by block diagonal matrix of butterfly matrices of size n, which can be viewed as a product of
butterfly factor matrices (n²) ....B
_.(²) B (n?)
B (n²)
Step 3: Permute the rows:
We permute the rows (with bit reversal permutation), which performs bit reversal permutation on each column. This corresponds left multiplication by permutation matrix P,. Since we are permuting the rows, P, permutes the entries at the granularity of each n-chunk. Since Steps I and 2 each performed an identical computation to each n-chunk we can move this row permutation before Step 2, combining P. and P, into single permutation P.
Step 4: Multiply each column by butterfly matrix
Consider multiplication by the first factor matrix. In each row, this matrix is taking linear combinations of adjacent column entries. In our length-n² vector, these entries will exactly n indices apart.
Therefore this multiplication can be handled by butterfly factor matrix (x²x), Similarly, that this butterfly multiplication can be expressed as multiplication by a product of butterfly factor (n matrices B (nn") n² ...B(M B((²), Combined with the factor matrices from Step 2, these form butterfly
find
(n²),
matrix B of size n
In all, we see that the 2-D DFT may be realized multiplication by a permutation matrix P followed by multiplication by a butterfly matrix B. The same argument as Lemma J.I shows that F ).
Remark J.11. An analogous argument (using the separation property of the respective transforms) can be used to argue that 2-D Discrete Sine and Discrete Cosine transforms are in )B, and that 2-D Hadamard Transforms are BB*
Lemma J.12. Let C2, be 2-dimensional convolution matrix. Then C² E BB
Proof. We can express a 2-D convolution matrix as C2 = (FF)) 'DF?, a. where D is diagonal, F the 2-D Fourier transform and (FF)-1 is the inverse 2-D Fourier transform. From the proof of Lemma 1.10. we see that that we can express F2 (and similarly (F))-1) as the product a butterfly matrix and permutation matrix. The rest of the argument is analogous the proof of Lemma J.5
Remark J.13. Using an inductive argument, we can show that all k-dimensional (k E Z) variants of the above transforms, expressed as n² n matrices are contained in BB"" (BB*)² To do this, we use the separation property of the transforms to break them into a 1-dimensional transform (the inductive hypothesis) followed I-dimensional transform.
35

---

Published as a conference paper at ICLR 2020
K THE ORTHOGONAL KALEIDOSCOPE HIERARCHY
Through practical application the butterfly matrices, it has been found useful to constrain them in orthogonality. In Section K.T we will modify the existing kaleidoscope hierarchy create the orthogonal kaleidoscope hierarchy OBB. Then, in Section K.2 we will argue that all orthogonal matrices, and result all matrices, can also be expressed in this hierarchy in O(n) width. Lastly, in Section K. we will argue that permutation matrices and sparse matrices also exist in this hierarchy in ((1) width, which in turn implies corresponding result for matrices with low-depth arithmetic circuits.
K.1 DEFIITTION
The definition the orthogonal butterfly identical to the original butterfly, with the constraint that all butterfly factors orthogonal. We specify this definition below:
Definition K.1 (Analog of Definition 2.1). An orthogonal butterfly factor of size k 2 2 (denoted as B&) is butterfly factor that is also orthogonal.
Definition K.2 (Analog of Definition 2.3). An orthogonal butterfly matrix of size n (denoted as B()) is butterfly matrix with all butterfly factor matrices being orthogonal.
Note that the above definition implies that an orthogonal butterfly matrix, as well as its conjugate transpose, is orthogonal.
The orthogonal hicrarchy definition nearly mimics the original hierarchy Definition as follows:
Definition K.3.
We say that
matrix M E B if we can express M (())
We say that an n. n matrix M E B" we can express M
((m)
We say that an n. X matrix M E OBB if we can express M DM for some Mi E B, M2 E B", and diagonal matrix D. Note that D need not be full rank.
Width and expansion in (OBB); mimic the same definition as in the original hierarchy. using OBB instead of BB*, such that (OBB)".
By padding if necessary, will assume that n is power of 2.
K.2 EXPRESSIVITY
In this subsection we prove that all orthogonal (resp. unitary) matrices are contained in OBB", To do this, we consider the class of Householder reflections, given by I 2uu" for any unit vector (Householder 1958):
Lemma K.1. All Householder reflections are OBB with inner diagonal matrix I.
We will prove this lemma shortly. First, we use this lemma to present a decomposition for all orthogonal (resp. unitary) matrices.
Lemma K.2. Let M be an n x n orthogonal/unitary matrix. Then M E (OBB)"-.
Proof. We consider the QR decomposition of M. is known that we can compose M into product of n Householder reflections and an orthogonal/umitary diagonal matrix (Householder 1958 10 From Lemma K. each Householder reflection is in OBB.
To complete the proof, we argue that R can be folded into the rightmost butterfly matrix. Let Q: be the rightmost butterfly factor matrix in (E (())), Right multiplication of Q by scales each
columns of Q by some E C with ||c|| = (R is unitary diagonal). This preserves both the sparsity
10Q is the (orthogonal/unitary) product of Householder reflections. R, the remaining upper triangular matrix after performing these reflections, itself orthogona//unitary, and therefore diagonal.
36

---

Published as a conference paper at ICLR 2020
pattern of Q1 and the orthogonality of its columns. Moreover, the norm of each column of Q₃ R is 1. Therefore, Q₂ R is an orthogonal butterfly factor matrix, so M QR E (OBB)"-1 as desired.
We now return the proof of Lemma K.1
Proof of Lemmal K.1 Given C (n power of 2), let un ul: n/2) C2/2 u, u(n/2
Cn/2 denote the first and second halves of u.
To show that E OBB with inner diagonal matrix I, we proceed by induction. The base case for
2 is trivial. It suffices to show that there exist unitary butterfly factors L, R such that LHR has
In/2 2vovv
the form
for some unit vectors Vo, E C2/2
0
In/2 2v
Define
if Lo [i]] 3
un #0
#0
(Vol) vi(i))
[3]
(5)
(1,0)
otherwise
It is easily checked that
vol vol vil0 vi
vo [
un M
+ v [1]
u
Io uo]ii] +
(6)
V
uo []] voli un
We choose
Diag( vil Diag(va V1)
Dia (iag(-vo)
voli
vi
and R = L L, R are (permuted) direct sums of blocks of the form
which are
vili
voli
orthogonal by construction (via ()). Hence, L E B and R E (B
Further,
Diag vō)
Diag(vi)
uo
Diag vo)
Diag(vi)
LHR
I 2
Diag(va) V1)
Diag( (vo)
u1
m1
Diag(v1)
Diag( vo)
Diag( (v)) Diag(v1)
Diag(vi
[uo
Ug
Diag (vo) Diag( v1)
Diag(vi)
1-2
Diag
vol
u1
Diag -vo)
I-22 vo o Ug + + ou Un
Vo o Un
+ vi
U1
Vo
un
w
w
where denotes the Hadamard product. From
Uo
2
E [n/2]
E [n/2 n]
Denoting the first half of this vector by wo E CC/2 we have
LHR I Swow
0 I
where ||wll2 = ||u||2 = 1. The result follows inductively.
As an immediate corollary, we can use Singular Value Decomposition to obtain a factorization for an arbitrary matrix.
Corollary K.3. Let M be an arbitrary n matrix. Then, M E (0-B)2n-1, where all but one matrix in the decomposition is orthogonal (unitary).
Proof. By employing Singular Value Decomposition, we can decompose M as - UEV" where V are orthogonal and Σ is diagonal. By Lemma K.2 U, V E (OBB)*-1 and trivially d Σ E OBB. Hence, M E (OBB) Note that Σ is the only matrix in the decomposition that is not orthogonal (unitary).
37

---

Published as a conference paper at ICLR 2020
K.3 CONSTRUCTIONS
We show that we can construct s-Sparse matrices in the OBB hierarchy with the same width as the BB hierarchy. The proof follows structure that of Theorem 3 We begin by arguing about permutation and step matrices, then using the same factorization to argue that matrices with at most NNZ are contained in (BB*)* Then, we will appeal modified sum closure lemma extend the argument to matrices of general NNZ. Similar to Appendix (F) we can use these results to place all matrices with low- circuits for matrix vector multiplication the OBB hierarchy.
K.3.1 PERMUTATIONS
We begin by presenting the argument that permutations are included in OBB a corollary to Theorem 2
Corollary K.4. Let P be a permutation matrix. Then P BB
Proof. We appeal to the decomposition from Theorem 2 noting that all butterfly factor matrices constructed in the proofs of Lemmas G.3 G.I are are permutation matrices, and thus are orthogonal. Hence, E OBB where the inner diagonal matrix
Similarly, the construction of Lemma also show that permutations are included in B B. Corollary K.5. Let P be a permutation matrix. Then B.
To prove the containment of sparse matrices within the OBB hierarchy, we make use of the following lemma.
Lemma K.6. Let be a permutation matrix and diagonal matrix. Then there exist diagonal matrices D' and D" such that:
PD = D'P
DP = PD"
Proof. Let a be the permutation such that P[i.j] = =(,,0)--
Define D' such that D'(or(J), D...). Then, if = a()):
(i.) P(i,j) j. -o)
(D'P)[i,))
Otherwise, if + o(j), then (PD) (i) Hence, PD D'P.
Define D" such that D"[,,]] = D(o(j), An analogous argument to above shows that DP = PD"
K.3.2 STEP MATRICES
In the BB hierarchy (Lemmal I.2 were able to show that horizontal step matrices are butterfly matrices. Here, we present a similar result for the OBB hierarchy.
Lemma K.7. Let be an n horizontal step matrix. Then we can decompose H DO, where D is a diagonal matrix and O B.
Proof. Throughout the proof, we make reference to the original horizontal step matrix construction given in Lemma 1.2 and its proof.
To begin, we show that an arbitrary 2 2* butterfly factor H2 in the decomposition of H can be expressed as the product of a diagonal matrix and an orthogonal butterfly factor. Since a butterfly factor is direct sum of x matrices, there is permutation matrix P2s such that conjugation of Hyt by Pat 2* gives block diagonal matrix H of 2 2 x 2 matrices, i.e.
P H.. P H
(See Figure 10 for an illustration.) Specifically, Pas is the permutation where:
P. [2i, of
P. P. =
38

---

Published as a conference paper at ICLR 2020
Ps
Hg
P
H
S
Figure 10: Block diagonalization of Hg
We argue that each of these 2x blocks can be decomposed into a diagonal matrix times an orthogonal matrix. Note that the butterfly factor matrices constructed in the proof of Lemma 1.2 each have at most one non-zero entry per column. Hence, there are 4 cases to consider. Note that matrices with at most one non-zero entry are exhausted by Cases 1 and 2.
0
a
0
0
Case 1:
0 b
0
D
O
00_
a
Case 2:
6 0
0
6
O
Case 3:
a
b
Vo²
62
Va 78
a 0
0 0
D
0
0
0
Case 4:
Va
V b
a
a b
0
Va
+ ba
Vaa
D
In the last two cases, O is a 2 x 2 rotation matrix, which is commonly known to be orthogonal. Assume that we perform the above decomposition on all of the blocks of H in parallel, therefore expressing H 2+ D'O', We now have
H2 P D'O''
By Lemma K.6 we can rewrite this as
H2 = D'P O'P
Note that P O'P the product of three orthogonal matrices, and thus orthogonal. Additionally, the construction P2t ensures that P O'P 2= butterfly factor Hence, H2 can be expressed the product of diagonal matrix and an orthogonal butterfly factor, as desired.
Now, we show that this decomposition butterfly factors implies Lemma K. 7 By performing this
decomposition in parallel on each butterfly factor, we conclude that any butterfly factor matrix (n)
of can be decomposed as H (m)
D2 O
12 2F
2F
Conjugation by Pys is isomorphism from 2 x 2 butterfly factors onto block diagonal matrices with k- 2 x blocks. Therefore, conjugation by P. P maps a block diagonal matrix a butterfly factor.
Note that block diagonal matrix composed of orthogonal matrices is, itself, orthogonal.
39

---

Published as a conference paper at ICLR 2020
We complete the argument by induction The base case 2 holds by the observation about
butterfly factor matrices above. Assume that any horizontal step matrix of size 1 x "t can be expressed diagonal matrix times orthogonal butterfly matrix. Now, consider the horizontal step matrix H. From Lemma 1.2 H can be expressed as
2 2
Hi 0
H = B
(1)
H2
where H1, H2 are 2 x horizontal step matrices. By our inductive hypothesis,
O
0
02
where D1 is diagonal and O,, O2 are x matrices in B. However, B.R D1 a butterfly factor, and therefore can be expressed as D, !
in) Therefore,
O
0
= D (n)
D,.0,
0 02
with B, as desired.
Just with the BB" hierarchy, the decomposition of vertical step matrices falls out as immediate corollary to the horizontal step matrix proof.
Corollary K.8. Let V be a vertical step matrix. Then we can decompose V O'D, where is diagonal matrix and O E B*
K.3.3 SPARSE MATRICES
Now that we have argued about the decomposition of permutation and step matrices in the OBB hierarchy, we leverage the construction from Lemma I.] to argue about matrices with most NNZ.
Corollary K.9. Let S be an x v malrix with at most n NNZ Then, S E (OBB)
Proof. We the construction from Lemma I.I along with Lemma K.7 and Corollary K.8 to express S as:
= 0 D2 0g0, 0,,,
P H
PHPPY
V V
P3
with each O E B, each O' E B", and each Dj diagonal. Since P2 permutation, by Corollary K.5 we can write it as O Ög for some Og 3" and Og E B. Moreover, noting that O'2 and Oş are permutations, we make use of Lemma K.6 to re-express S as:
$ O,D'O O, O O&D
M
M
Ma M.
Note that each M, OBB. Hence, S (OBB)4 desired.
Just as in Appendix [ we would like to extend this orthogonal- based construction to capture matrices of general sparsity. To accomplish this, introduce addition closure lemma analogous to Lemma K.10 for the OBB hierarchy.
Lemma K.10. Let A be k x matrices in (OBB). then Σm A E (OBB)
With Lemma K. we arrive at the following Corollary on general orthogonal sparsity. 4
Corollary K.11. Let S be matrix with NNZ. Then, S (OBB),
40

---

Published as a conference paper at ICLR 2020
Proof. Just as in the proof of Theorem accomplish this using sum of matrices of most n. NNZ. For handling the sum of matrices, we need to appeal to Lemma K.10
To conclude the argument, give the proof of Lemma K.10
Proof of Lemma K.10
For each sis m, let EA, E Fekxek be defined such that A, = SEA, S
(with S as Definition 2.4). Note that EA, E (OBB) Consider matrices of the form:
0
0
Ea.
0
0
0
ck
0
0
0
Lek
V2
2
2ek
vp
2ek
0
0
0
I
ck
0
Lc
0
0
-EA.
2eck
v/2 2ec
0
0
EA.
0
0
0
0
Lek
V2
Lak
0
Lek
0
O E B(eck)
M, p4okx4cc
K
P E B (1eR)
2ch
Note that K, a block diagonal matrix composed of matrices in (OBB) s is itself in (OBB) " since
Tek
0
0
Tek
0
07
Le
0
0
0
W
0
Lek
0
0
0
L2
0
0
0
Lek
0
0
K
0
D
0
0
0
j=1
0
0
Lek.
0
0
0
0
0
I
Ly E
B
Diagonal
Rj E B
where each O, is a ek ek matrix in B, and each O', is ek x ek matrix in B*. L., (the leftmost factor) is block diagonal matrix composed of 4 ek x ek matrices in B. Therefore. can fold O into this factor (since a butterfly factor in B (4eR)
dck was not yet used in L to conclude that OL E B. Similarly, since no btterfly factor from B B has been used in R1, we may fold P into R₁ to conclude that P,P E B Finally, we address the scalar multiple of 2 by multiplying all entries of any diagonal matrix in the decomposition of K by V2. Hence, we may conclude that M, E (OBB)".
Through repeated application (ı times) of the identity
A
B1
I
0
0
C₁
A
+
B
C
0
I
0
0
0
I
0
0
I
0
0
IL
A
B2
0
0
C2
A
B2
0
C1
0
0
I
0
0
0
0
we see that
L
EA.
0
E
0
Tek
0
0
M,
Lek
-E
.EA..
E
0
EAI
2
0
0
0
M E 4eenx4on
Therefore, M (OBB) Next, note that
0
Leb
Lek
Σ 1=1
A.
SM
Lok
Lkk
(
ST
0
Lck
-Tck
Lek
-ek
0
We would like to show that we can fold Q into the rightmost OBB factor of M. The rightmost matrix in the decomposition of M is P. Note that
Lek
L
Lek
0
PQ
Lek
0
Lek
0
V2
I Lak
0
0
0
v2
Lak
/2
Izek
L,k
Lck
0
-Lk
0
-I,k
0
0
0
0
I
0
V2
lakk
v2
1nnk
B (1ek)
(1ck)
B
(dek)
2ek
41

---

Published as a conference paper at ICLR 2020
Just as earlier, the factor of v2 can be multiplied through any diagonal matrix. Also, these two orthogonal butterfly factor matrices can be folded into the the rightmost R matrix (the decomposition of K above does not use these two, rightmost butterfly factors). Hence, Ex= A, E (OBB)42 2 as
desired.
K.3.4 ARITHMETIC CIRCUITS
Just as in Theorem ! we can use the sparsity result in Lemma K. 10 to place matrices with low-depth (linear) arithmetic circuits for matrix vector multiplicatiin in the OBB hierarchy.
Corollary K.12. Let M be arbitrary vector can be represented as a a linear arithmetic circuit C comprised of s gates ((d) (including inputs) and having depth d. Then, M E (OBB) ((2)) O(.))
x matrix such that matrix-vector multiplication of M times an
Proof. We use the construction given in the proof of Theorem 1 Corollaries K.9 and K.4 recover the same width and expansion factor with the OBB hierarchy.
allow to
L RELU NETWORK WITH STRUCTURED WEIGHT MATRICES
We show that for any neural network with ReLU nonlinearities and whose weight matrices have arithmetic circuits with few gates, its linear network counterpart (obtained by removing all the ReLU's) also has arithmetic circuit with find the smallest arithmetic circuit augmented with ReL.U gates to represent a ReLU network, one might as well try find the smallest arithmetic circuits that represent the matrix-vector multiplication of each weight matrix.
many more gates. This implies that in trying
Proposition 2. Consider neural network architecture consisting of L layers with weight matrices W W,...., WL paxn and ReLU nonlinearity in between.
Suppose that matrix-vector multiplication of W: times an arbitrary vector v can be represented as linear arithmetic circuit with 8; gates (including imputs). Then there exists an arithmetic circuit augmented with ReLU gates with Σ 8; + Ln total gates that computes the output of the network an arbitrary input vector
ReLU(W (... ReeUU(W (W........WWWWW.nnn.....
Conversely, if there is an arithmetic circuit augmented with ReLU gates with s total gates that computes all the activations of the network ReLU(W.iv.... ReLU(W, w.W...RReLU.... arbitrary input v, then there exists an arithmetic circuit augmented with ReLU gates with 2s 2Ln total gates that computes the activations of the network without ReLU W W.,...., WL WIv.
(v)) for an
Proof of Proposition To compute the output of the network ReLU L(... R...(ReLLU/ (w)))), we first compute the matrix-vector product W1 v with arithmetic circuit of 81 gates by assumption, and use n other ReLU gates to compute the pointwise ReLU. Then we repeat the process for layer 2, 3, ..... L, using the arithmetic circuits of W,,... ...... Wr and Ln additional gates for ReLU. In total we obtain an arithmetic circuit augmented with ReLU gates with Σ 8; + Ln total gates.
Conversely, to build an arithmetic circuit augmented with ReLU gates to compute WIv.... W.... WIv, we pass and then -v through the circuit that computes ReLU(W 1x) for an arbitrary to get ReLU(Wiv) and ReLU ( W.v). Noting that æ = ReLU(x) - ReLU(-=2), we can use n additional gates to compute W v from ReLU(W, v) and ReLU(-W.
Repeat the process for layer 2, ... T. (for example, pass W,v and - W to the circuit that computes W2x for an arbitrary x on layer 2). Overall we need to double the cireuits that computes all the activations of the network We also need n additional gates per layer to compute the negation of the input to that layer (e.g. computing from v). and n additional gates per layer to subtract the output of the ReLU circuit (e.g. computing Wiv from ReLU(Wiv) and RcLU(- (cLU((Wrv)) Therefore we can construct an arithmetic circuit augmented with ReLU gates with 2s 2L total gates that computes the activations of the network without ReLU W,v, W.,...., W.... Wiv.
(eLUUWWiv...... (...(W L Re..eeeLLWe.eeee (I)). requiring 2s gates.
42

---

Published as a conference paper at ICLR 2020
We now prove asymptotic bound on the VC dimension of ReLU network whose weight matrices are kaleidoscope matrices with bounded width and expansion.
Proposition 3. Let F be the class of ReLU neural networks consisting of L layers, where each layer K K-matrix with width and expansion bounded by some constant C. Suppose that the network has W total parameters. Let sign F denote the corresponding classification functions: {x + sign [(x) E F). Then this class has VC dimension:
VCdim(sign F)
O log W).
We leverage the result from Thomas et al. (2018) for the case where the entries of the weight matrices interact multiplicatively, but with polynomially bounded degrees. This proof is similar to the VC bound for ReLU networks whose weight matrices are butterfly matrices (Dao et al. 2019)
Proof. To use Theorem 3 of Thomas et al. (2018) we simply need to check that the entries of the linear layer, as polynomials of the parameters, has degree most Ci mi for some universal constant C1 > 0, where my is the size of output of the 1-th layer. If the network weight matrices are K-matrices with bounded width and expansion, each weight matrix is a product of at most c3 log my sparse factors, for some universal constant C3 0. This means that the degree is polynomially bounded, which satisfies the condition of the theorem. Therefore the VC dimension bounded to be almost linear in the number of parameters:
VCdim(sign F) = O W).
M ARITHMETIC CIRCUIT PRIMER
We give a quick overview of arithmetic circuits. This is a model of computation that has been studied for numerous computational problems (and is the basic model for algebraic complexity theory). For our purposes, we will exclusively focus on arithmetic circuits for the matrix- multiplication problem. For more detailed exposition, the reader is referred to the standard book on this topic (Bürgisser et al. 2013).
Definition M.1 (Arithmetic Circuits). An arithmetic circuit that computes y Ax (for A E (RXxn) has n input gates (corresponding to I[m 1)). All the internal gates correspond to addition, subtraction, multiplication and y00). ... 11 over the underlying field E. The circuit also allowed to use constants from FF for 'free.' division
-]) and m output gates (corresponding to
The definition of the internal gates can depend on A (as well x of course). In other words, one can 'bake' the knowledge about A into the circuit.
The size of a circuit is plus the number of addition, multiplication, subtraction and division gates used in the circuit. The depth d of a circuit is the minimum number layers such that all gates in given layer take as its imput gales from previous layers!"
One drawback of arithmetic circuits (especially for infinite fields e.g. F= R, which is our preferred choice in this work) is that they assume operations over F can be performed exactly. In particular, it ignores precision issues involved with real arithmetic. Nonetheless, this model turns out to be a very useful model in reasoning about the complexity of doing matrix-vector multiplication for any family of matrices.
Perhaps the strongest argument in support of arithmetic circuits is that a large (if not overwhelming) majority of matrix-vector multiplication algorithm also imply an arithmetic circuit of size comparable to the runtime of the algorithm (and the depth of the circuit roughly correponds to the time taken to compute it by parallel algorithm). For example consider the obvious algorithm to compute Ax (i.e. for each i E [m]] compute yli] as the sum > k=0 A (x()). It is easy to see that this algorithm
implies an arithmetic circuit of size ((m) and depth Oloog n
15
13 Here we assume all the gates have two inputs.
1*The input layer corresponding to the input gates does not contriubte to the depth.
The claim on the depth follow from the fact that each of the sums Σ1 A [[]]]]]]]]] can be computed in parallel, Further, the sum for each E [ma] can be done in log, m depth by first computing the partial sums A (i|2) 22'"'((22'') + A [1][22] + (2 + 1] for all j' E [n/2] parallel and recursively computing pair-wise sums till we are done.
43

---

Published as a conference paper at ICLR 2020
One thing to note about the arithmetic circuit above is that all the multiplications involve at least one input that a constant from IF (recall that we can assume that the entries of A are constants that can be used to build the circuit). This leads to the following important sub-class of arithmetic circuits:
Definition M.2 (Linear Arithmetic Circuits). An arithmetic circuit is called a linear arithmetic circuit if only addition, subtraction and multiplication. Further, every multiplcation has fixed constant from as at least one of its two inputs. In other words, all gates in the circuit are linear functions of their inputs (i.e. of the form ax + by for fixed constants a, b 19).
Intuitively for the matrix- multiplication, it makes sense to consider linear arithmetic circuits since the final function want compute Ax indeed linear function of its inputs. For inifinite fields (e.g. F R or IF = C) it turns out that this is essentially without loss of generality:
Theorem 4 (Bürgisser al., 2013)). Let IF be an infinite field. Any (general) arithmetic circuit to compute Ax over IF of size and depth d can be converted into a linear arithmetic circuit of size (s)) and depth O(d).
The above result implies that for asymptotic considerations, linear arithmetic circuits for matrix-vector multiplication are equivalent general arithmetic circuits 16
One important property of linear arithmetic circuits of depth d, which we will use in our arguments, that such circuit can be equivalently represented product of d sparse matrices (see the proof of Theorem for the precise derivation!"
As mentioned carlier, vast majority of efficient matrix vector multiplication algorithms are equivalent to small (both in size and depth) linear arithmetic circuit. For example the FFT can be thought of as an efficient arithmetic circuit compute the Discrete Fourier Transform (indeed when one converts the linear arithmetic circuit for FFT into matrix decomposition [T then each matrix in the decomposition a butterfly factor, with each block matrix each factor being the same). For an illustration of this consider the DFT with 4 as illustrated in Figure 11
Figure 11: DFT of order
Figure 12 represent the arithmetic circuit corresponding to FFT with 4.
16This follows from the fact that by definition any linear arithmetic circuit is also an arithmetic circuit; the
other direction follows from Theorem 4
"To best our knowledge, this connection was explicitly made by De Sa et al. 2018 8 though connection seems to be folklore.
Using the conversion mentioned in the paragraph above.
44

---

Published as a conference paper at ICLR 2020
to
W1
W2
W3
+
+
a.e by
+
Semantics of gate
11
22
03
Figure 12: Arithmetic circuit for 4-DFT from Figure 11
Finally, Figure 13 is representation of the arithmetic circuit of Figure as product of a butterfly matrix and (the bit-reversal) permutation. We note that our generic arithmetic circuit to decomposition into BB is not as tight as in Figure 13
B 4)
4) B
P
2
Figure 13: Decomposition of DFT Figure via the arithmetic circuit Figure 12
One reason for the vast majority of existing efficient matrix vector algorithms leading to (linear) arithmetic circuits is that they generally are divide and conquer algorithms that use polynomial operations such polynomial multiplication or evaluation (both of which themselves divide and conquer algorithms that use FFT as a blackbox) or polynomial addition. Each these pieces are well known have small (depth and size) linear arithmetic circuits (since FFT has these properties). Finally, the divide and conquer structure the algorithms leads to the circuit being low depth. See the book of Pan Pan 2001 for more elaborate description of this connection.
In fact, the recent work of De Sa et al. (De Sa et al. 2018) makes this fact explicit and presents the most general known structure matrices that imply near-linear size linear arithmetic circuits for the corresponding matrix vector multiplication. Their work combines two separate classes of structures matrices- orthogonal polynomial transforms (Driscoll et al.) 1997 Szegö 1967) well as matrices with low displacement rank (Kailath et al. 1979 Olshevsky & Shokrollahi 2000) and presents linear class of linear arithmetic circuits solve their matrix vector multiplication problem. We note that structured matrices with low displacement rank have been used to replace fully connected layers
some neural network architectures (Sainath et al. 2013 Thomas al. 2018).
45


Reviews:
[{"review_id": "S1g74Sfq9H", "reviewer": "AnonReviewer4", "summary": "", "questions": "", "limitations": "", "rating": 8, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "Summary\nThe authors introduce kaleidoscope matrices (K-matrices) and propose to use them as a substitute for structured matrices arising in ML applications (e.g. circulant matrix used for the convolution operation). The authors prove that K-matrices are expressive enough to capture any structured matrix with near-optimal space and matvec time complexity. The authors demonstrate that learnable K-matrices achieve similar metrics compared to hand-crafted features on speech processing and computer vision tasks, can learn from permuted images, achieve performance close to a CNN trained on unpermuted images and demonstrate the improvement of inference speed of a transformer-based architecture for a machine translation task.\n\n\t\t\nReview\nThe overall quality of the paper is high. The main contribution of the paper is the introduction of a family of matrices called kaleidoscope matrices (or K-matrices) which can be represented as a product of block-diagonal matrices of a special structure. Because of the special structure, the family allows near-optimal time matvec operations with near-optimal space complexity for structured matrices which are commonly used in deep architectures. \n\nThe proposed approach is novel. It gives a new characterization of sparse matrices with optimal space complexity up to a logarithmic term. Moreover, the proposed characterization is able to learn any structured matrix and matvec time complexity of the K-matrix representation is near-optimal matvec time complexity of the structured matrix. Even though in the worst-case complexity is not optimal, the authors argue that for matrices that are commonly used in machine learning architectures (e.g. circulant matrix in a convolution layer) the characterization is optimal. This results in a new differentiable layer based on a K-matrix that can be trained with the rest of an architecture using standard stochastic gradient methods. However, it is worth noting that the reviewer is not an expert in the field, and it is hard for him to compare the proposed approach with previous work.\n\t\t\t\t\t\t\nThe paper is generally easy to follow. Even though the introduction of K-matrices requires a lot of definitions, they are presented clearly and Figure 1 helps to understand the concept of K-matrices. The experimental pipeline is also clear.\n\nGiven the special structure of the family, the reviewer might guess that having K-matrices can slow down the training, i.e. it might require more epochs to achieve the reported results compared to baselines. Providing training plots might increase the quality of the paper.\n\nThe experimental results are convincing. First, the authors show that K-matrices can be used instead of a handcrafted MFSC featurization in an LSTM-based architecture on the TIMIT speech recognition benchmark with only a 0.4% loss of phoneme error rate. Then, the authors evaluate K-matrices on ImageNet dataset. In order to do so, they compare a lightweight ShuffleNet architecture which uses a handcrafted permutation layer to the same architecture but with a learnable K-matrix instead of the permutation layer. The authors demonstrate the 5% improvement of accuracy over the ShuffleNet with 0.46M parameters with only 0.05M additional parameters of the K-matrix and the 1.2% improvement of accuracy over the ShuffleNet with 2.5M parameters with only 0.2M additional parameters of the K-matrix. Next, the authors show that K-matrices can be used to train permutations in image classification domains. In order to demonstrate so, they take the Permuted CIFAR-10 dataset and ResNet-18 architecture, insert a trainable K-matrix at the beginning of the architecture and compare against ResNet-18 with an inserted FC-layer (attempting to learn the permutation as well) and ResNet-18 trained on the original, unpermuted CIFAR-10 dataset. With K-matrix, the authors achieve a 7.9% accuracy improvement over FC+ResNet-18 and only a 2.4% accuracy drop compared to ResNet-18 trained on the original CIFAR-10. Finally, the authors demonstrate that K-matrices can be used instead of the decoder’s linear layers in a Transformer-based architecture on the IWSLT-14 German-English translation benchmark which allows obtaining 30% speedup of the inference using a model with 25% fewer parameters with 1.0 drop of BLEU score.\n\nOverall, the analysis and the empirical evaluations suggest that K-matrices can be a practical tool in modern deep architectures with a variety of potential benefits and tradeoffs between a number of parameters, inference speed and accuracy, and ability to learn complex structures (e.g. permutations).\n\n\nImprovements\n1. Even though K-matrices are aimed at structured matrices, it would be curious either to empirically compare K-matrices to linear transformations in fully-connected networks (i.e. dense matrices) or to provide some theoretical analysis.\n2. Section 3.3 argues that K-matrices allow to obtain an improvement of inference speed, however, providing the results of convergence speed (e.g. training plots with a number of epochs) will allow a better understanding of the proposed approach and will improve the quality of the paper.", "extra_scores": {"experience_assessment": "I do not know much about this area.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory.", "review_assessment:_checking_correctness_of_experiments": "I assessed the sensibility of the experiments.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper at least twice and used my best judgement in assessing the paper."}, "extra_text": {}}, {"review_id": "HyeOD450tr", "reviewer": "AnonReviewer2", "summary": "", "questions": "", "limitations": "", "rating": 8, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "This paper introduces a structured drop-in replacement for linear layers in a neural network, referred to as Kaleidoscope matrices. The class of such matrices are proven to be highly expressive and includes a very general class of sparse matrices, including convolution, Fastfood, and permutation matrices. Experiments are carried in a variety of settings: (i) can nearly replace a series of hand-designed feature extractor, (ii) can perform better than fixed permutation matrices (though parameter count also increased by 10%), (iii) can learn permutations, and (iv) can help reduce parameter count and increase inference speed with a small performance degradation of 1.0 BLEU on machine translation.\n\nThis appears to be a solid contribution in terms of both theory and practical use. As I have not thought much about expressiveness in terms of arithmetic circuits (though I was unable to fully follow or appreciate the derivations, the explanations all seem reasonable), my main comments are regarding experiments. Though there are experiments in different domains, each could benefit from some additional ablations, especially to existing parameterizations of structured matrices such as Fastfood, ACDC, and any of the multiple works on permutation matrices and/or orthogonal matrices. Though Kaleidoscope include these as special cases, it is not clear whether when given the same resources (either memory or computational cost), Kaleidoscope would outperform them. There is also a matter of ease of training compared to existing approximations or relaxations, e.g. Gumbel-Sinkhorn.\n\nPros:\n - The writing is easy to follow and concise, with contributions and place in the literature clearly stated. \n - The Kaleidoscope matrix seem generally applicable, both proven theoretically and shown empirically (experiments are spread across a wide range of domains). \n - The code includes specific C++ and CUDA kernels for computing K matrices, which will be very useful for adaptation.\n - The reasoning using arithmetic circuits seems interesting, and the Appendix includes a primer.\n\nCons:\n - For the squeezenet and latent permutation experiments, would be nice if there is a comparison to other parameterizations of permutation matrices, e.g. gumbel-sinkhorn.\n - For the speed processing experiment, did you test what the performance would be if K matrix is replaced by a fully connected layer? This comparison appears in other experiments, but seems to be missing here for some reason. It would lead to better understanding than only comparing to SincNet.\n - The setup for the learning to permute experiment is not as general as it would imply in the main text. The matrices are constrained so that an actual permutation matrix is always sampled, and the permutation is (had to be?) pretrained to reduce total variation for 100 epochs before jointly trained with the classifier. Though this is stated very clearly in the Appendix, I hope the authors can also communicate this clearly in the main text as it appears to be a crucial component of the experimental setup.\n\nComments:\n - How easy is it to train with K matrices? Did you have to change optimizer hyperparameter compared to existing baselines? \n - There seems to be some blurring between the meaning of structure (used to motivate K matrices in the introduction) and sparsity (used to analyze K matrices). Structure might also include parameter sharing, orthogonality, and maybe other concepts. For instance, while Kaleidoscope matrices might include the subclass of circulant matrices, can they also capture the same properties or \"inductive bias\" (for lack of better word) as convolutional layers when trained?", "extra_scores": {"experience_assessment": "I have read many papers in this area.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper thoroughly.", "review_assessment:_checking_correctness_of_experiments": "I carefully checked the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory."}, "extra_text": {}}, {"review_id": "BJx4TPtRFB", "reviewer": "AnonReviewer3", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "The authors propose learnable \"kaleidoscope matrices\" (K-matrices) in place of manually engineered structured and sparse matrices. By capturing \"all\" structured matrices in a way that can be learned, and without imposing a specific structure or sparsity pattern, these K-matrices can improve on existing systems by \n* capturing more structure (that was not handled by the existing manually engineered architecture),\n* running faster than dense implementations.\n\nThe claim that \"all\" structured matrices can be represented efficiently is a strong one, and in section 2.3 the authors make it clear what they mean by this. Although the proof is long and beyond the expertise of this reviewer, the basic explanation given in section 2.3 makes their point clear for the non-expert reader.\n\nThe balance of the paper empirically tests the claims of learnable structure and efficiency.\n\nOn the basis that these experiments essentially bear out the claims of the paper, I selected to accept the paper.\n\nWeaknesses:\n\n1. Regarding the ISWLT translation task result:\nWith this dataset, it's a bit of a stretch to say there was \"only a 1 point drop in BLEU score\". That's a significant drop, and in fact the DynamicConv paper goes to significant lengths to make a smaller 0.8 point improvement. There are probably many other ways to trade BLEU score for efficiency, and without showing those other methods (and the point drops they have), it's not clear that K-matrices are a good way to speed up decoding a bit.\n\n\n\n", "extra_scores": {"experience_assessment": "I do not know much about this area.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper at least twice and used my best judgement in assessing the paper.", "review_assessment:_checking_correctness_of_experiments": "I assessed the sensibility of the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory."}, "extra_text": {}}]

Author rebuttal:

Meta-review: The paper generalizes several existing results for structured linear transformations in the form of K-matrices. This is an excellent paper and all reviewers confirmed that.
Decision: Accept (Spotlight)