Title: BLAST: Block-Level Adaptive Structured Matrices for Efficient Deep Neural Network Inference
Venue: NeurIPS 2024
Accepted: yes
Keywords: Efficiency

Compression

Low Rank

Pruning

Matrix Factorization

Structured Matrix

Acceleration

Optimization

Transformer

Large Language Model

Diffusion Model

Vision Model

Preconditioned Gradient Descent
Abstract: Large-scale foundation models have demonstrated exceptional performance in language and vision tasks. However, the numerous dense matrix-vector operations involved in these large networks pose significant computational challenges during inference. To address these challenges, we introduce the Block-Level Adaptive STructured (BLAST) matrix, designed to learn and leverage efficient structures prevalent in the weight matrices of linear layers within deep learning models. Compared to existing structured matrices, the BLAST matrix offers substantial flexibility, as it can represent various types of structures that are either learned from data or computed from pre-existing weight matrices. We demonstrate the efficiency of using the BLAST matrix for compressing both language and vision tasks, showing that (i) for medium-sized models such as ViT and GPT-2, training with BLAST weights boosts performance while reducing complexity by 70\% and 40\%, respectively; and (ii) for large foundation models such as Llama-7B and DiT-XL, the BLAST matrix achieves a 2x compression while exhibiting the lowest performance degradation among all tested structured matrices. Our code is available at https://github.com/changwoolee/BLAST.

BLAST: Block-Level Adaptive Structured Matrices for Efficient Deep Neural Network Inference

Abstract

Large-scale foundation models have demonstrated exceptional performance in language and vision tasks. However, the numerous dense matrix-vector operations involved in these large networks pose significant computational challenges during inference. To address these challenges, we introduce the Block-Level Adaptive STructured (BLAST) matrix, designed to learn and leverage efficient structures prevalent in the weight matrices of linear layers within deep learning models. Compared to existing structured matrices, the BLAST matrix offers substantial flexibility, as it can represent various types of structures that are either learned from data or computed from pre-existing weight matrices. We demonstrate the efficiency of using the BLAST matrix for compressing both language and vision tasks, showing that (i) for medium-sized models such as ViT and GPT-2, training with BLAST weights boosts performance while reducing complexity by 70% and 40%, respectively; and (ii) for large foundation models such as Llama-7B and DiT-XL, the BLAST matrix achieves a 2x compression while exhibiting the lowest performance degradation among all tested structured matrices. Our code is available at https://github.com/changwoolee/BLAST .

1 Introduction

Foundation models built on large deep neural networks (DNNs) have demonstrated remarkable performance in vision and language tasks. However, the size of these large networks poses both computational and storage challenges, especially in resource-constrained environments such as edge devices. The size of a single DNN often exceeds the capacity of the supporting hardware devices [1-5]. For example, Llama-70B [1] demands at least 140GB of memory solely for loading its weights in half-precision floating point representation, while the state-of-the-art commercial GPU only accommodates 80GB of memory. Furthermore, inference with these networks involves numerous dense matrix-vector operations, which can be limiting when computing power is constrained.

Fortunately, large (overparameterized) DNNs often exhibits parameter redundancy, where the intrinsic dimension of the weights is much lower than the ambient dimension. As such, the weights should be structured , possessing hidden properties such as low-rankness [6-9] or sparsity [10, 11]. Hence, it is possible to replace (or factorize) these dense existing weight matrices with structured ones without degrading performance [10-12]. However, using structured matrices that do not align with the true underlying structure of the weight matrices can result in significant performance degradation. We demonstrate this point in Figure 1 where we attempt to capture the structure of a diffusion model transformer (DiT) [13] using the low-rank structure to generate synthetic images. In Figure 1, we compress the model's linear layers by approximately 50% of the total number of parameters using low-rank weight matrices via singular value decomposition (SVD) and generate images with the compressed model (see Section 4.2 and Appendix C.3 for details). As shown in Figure 1 (middle), simply using the low-rank structure introduces unwanted artifacts in the generated images.

Original

Low-Rank

BLAST

:9-

GT

To address this issue, many flexible structures for modeling DNN weights have been proposed to minimize the misalignment between imposed and true low-dimensional structures. For example, Dao et al. [14] proposed the Monarch matrix, a specific type of Block Low-Rank (BLR) structure [15], in which all blocks share the same rank, intended for use in the linear layers of transformers [16]. Matrix multiplication with a Monarch matrix can be performed efficiently using batched matrix multiplication routines. Additionally, Chen et al. [17] investigated a block sparse plus low-rank structure. However, all of these methods still suffer from the fact that the underlying structure of each weight matrix is not known a priori. By imposing one of these structures, performance degradation may still occur due to misalignment. Recently, Lee and Kim [12] introduced a data-driven design called Generalized Block Low-Rank (GBLR). This approach employs multiple rank-1 blocks with various sizes and locations learned from data via differentiable masks. Unfortunately, the GBLR matrix is optimized for custom-designed hardware, as the learned block patterns are random. It has limited usability on general GPUs as the computation of GBLR matrices does not accelerate well on them.

In this work, we introduce the Block-Level Adaptive Structured (BLAST) matrix, a versatile and efficient design tailored to uncover various low-dimensional structures in the weight matrices of DNNs for accelerated inference on GPUs. Our matrix structure leverages shared bases across block matrices with block-wise diagonal coupling factors. This structure encapsulates different structures such as low-rank, block low-rank, block-diagonal matrices, and their combinations. BLAST matrices can be applied to the training scenario from scratch or compression after training. For training from scratch, we let the linear layers of the DNN to directly adopt the BLAST structure and learn its factors from data. The factors of the BLAST matrix are constructed to have well-defined gradients, allowing them to be optimized using popular methods like stochastic gradient descent (SGD) or Adam [18]. For compressing existing weights, we propose a factorization algorithm to learn the BLAST factors from pre-trained weights. The compression performance can be further improved by updating the BLAST factors using data, a process we call 're-training'.

We demonstrate the efficiency of BLAST by training Vision Transformers (ViT) [19] and GPT-2 [20] from scratch on various datasets, showing that it can reduce complexity by 70% and 40%, respectively. We also compress existing ViT and Diffusion Transformer (DiT) [13] models with BLAST matrices by 70% and 50%, respectively, demonstrating that BLAST compression (and re-training) achieves higher accuracy / quality compared to existing methods for ViT and DiT (see Figure 1). For the language tasks, we compress Llama-7B [1] by 50% via BLAST and re-train on 0.49B tokens, showing the lowest accuracy degradation with significant inference speedup on a NVIDIA A100 GPU. Overall, our contributions can be summarized as follows:

U

i,j

V

T

i,j

A

i,j

=

U

i,j

V

T

i,j

Monarch [14]

U

V

T

A

=

UV

T

Low-Rank

D

i,i

A

i,j

=

D

i,i

if

i

=

j

,

O

o.w.

Block-Diagonal

A

=

∑

r

′

k

=1

u

k

v

T

k

GBLR [12]

r

U

i

V

T

j

S

i,j

n

b

r

A

i,j

=

U

i

S

i,j

V

T

j

BLAST (Proposed)

We propose a novel block-structured matrix called BLAST that encompasses a wide range of matrix structures, allowing for faster matrix multiplication . Various existing structured matrices such as Low-Rank, Monarch [14], and Block Diagonal matrices can be expressed using the BLAST matrix.

We provide gradient descent-based methods to find the BLAST factors for DNN weights. We empirically show that standard DNN training with the BLAST weight matrices effectively recovers the original accuracy while achieving up to a 70% reduction in computational complexity.

In cases where pre-trained dense weights are available, we propose a preconditioned gradient descent factorization algorithm to decompose the weights to BLAST factors for compression and further re-training. Our experimental results show that pre-trained foundation models for vision or language tasks can be compressed by 50% using BLAST matrices.

Notation and Organization. We use σ 1 ( X ) to denote the largest singular value of the matrix X . The notation ⊙ indicates Hadamard product.

The rest of the paper is organized as follows. In Section 2, we introduce the BLAST matrix and discuss its properties. In Section 3, we propose a methodology to train/compress DNNs with BLAST weight matrices. In Section 4, we demonstrate the effectiveness of the BLAST weights in improving efficiency without noticeable accuracy degradation. We discuss related works in Section 5, and conclude in Section 6.

2 Block-Level Adaptive Structured (BLAST) Matrix

Consider a square matrix 1 A ∈ R n × n for some n ∈ N , which has an unknown intrinsic lowdimensional structure. We first equally partition the matrix A into b × b blocks of size p × p where b, p ∈ N are constants such that n = bp :

Then, the BLAST matrix parameterizes each block matrix A i,j using three factors:

where U i , V j ∈ R p × r are the left and the right factors, respectively, and S i,j = diag( s i,j ) is an r × r diagonal matrix whose diagonal entries are s i,j ∈ R r . We provide a visual representation on the rightmost side of Figure 2, and illustrate how this structure differs from other types of matrices. While the BLAST structure may appear similar to SVD, there are two notable differences: (i) the left and right factors do not need to be orthonormal, and (ii) the diagonal entries do not need to be positive. These distinctions make it more flexible in capturing different types of low-rank structures.

As illustrated in Figure 2, the BLAST matrix also comes with two unique properties:

Factor Sharing: The left factor matrix U i of size rp is shared across b blocks at the i th row, i.e., A i, 1 , . . . , A i,b . Likewise, the right factor V j is shared across the blocks at the j th column. On the other hand, the diagonal factor s i,j of size r is specific to each block A i,j . Hence the total number of parameters of an n × n BLAST matrix with b × b number of blocks of rank r is 2 rpb + rb 2 = 2 nr + rb 2 . This reduces the number of parameters b times by enforcing the blocks at the same row or column share the same bases.

Individual Diagonal Factors: The individual diagonal factors of each block matrix are the source of the adaptivity and flexibility of the BLAST matrix. By changing the values of the diagonal factors, the BLAST matrix can encompass a wide variety of matrix structures. These factors can be estimated using gradient descent , since s i,j is a real-valued vector and A i,j = U i diag( s i,j ) V T j is linear to s i,j .

Low-Rank Matrices as Special Cases of BLAST To demonstrate how the BLAST matrix can capture different types of structures, we present an example showing how the BLAST matrix can encompass a low-rank matrix. Consider the case where all the diagonal factors are ones, i.e., s i,j = 1 r for all i, j = 1 , 2 , . . . , b . Then, we can write the block matrix as follows:

Hence, if the true underlying structure is low-rank, we can expect the BLAST matrix to learn this specific structure. Similarly, we show in Section A.1 that the BLAST matrix can construct low-rank , block-diagonal , and block low-rank matrices through different diagonal parameters. A combination of these canonical structured matrices, such as a low-rank with block-diagonal matrix, can also be achieved by simply concatenating the factors of each matrix.

Matrix Multiplication DNNs involve numerous matrix-vector (matrix-matrix) multiplications in the form of y = Ax ( Y = AX ). Algorithm 1 depicts the BLAST matrix-vector multiplication procedure. Consider the partitioned input vector x = [ x T 1 , x T 2 , · · · , x T b ] T and the partitioned output vector y = [ y T 1 , y T 2 , · · · , y T b ] T . The i th partitioned output vector y i is then computed by the sum of the b block-wise matrix-vector multiplications along j = 1 , . . . , b :

Algorithm 1 BLAST Matrix-Vector Product

The number of multiplications required to perform the matrix-vector multiplication y = Ax is (2 n + b 2 ) r . The matrix multiplication z j = V T j x j , j = 1 , . . . , b is computed once and shared across i = 1 , . . . , b , whereas the matrix multiplications in Line 3 and Line 6 of Algorithm 1 can be executed in parallel, e.g., by torch.bmm in PyTorch [21]. An implementation of Algorithm 1 for general matrix or tensor inputs can be found in Appendix A.

3 Applications of BLAST Matrices

There are two main applications of BLAST matrices: (i) training from scratch with the BLAST structure and (ii) compression of pre-trained weights using BLAST factorization.

3.1 Training from Scratch using BLAST Matrices

To train a DNN on a dataset, parameters are typically initialized randomly and updated through stochastic gradient descent. In this setting, BLAST can replace dense weights to learn structures

from the training data. Instead of using random dense weight matrices, the model is initialized with random BLAST factors U i , V j , s i,j . Since the forward and the backward path of the linear layer involving the weight matrix is composed of three linear operations as in Equation (3), the derivatives of the minibatch loss can be back-propagated by automatic differentiation frameworks [21]. Hence, all of the trainable parameters of BLAST can be updated using conventional optimizers (e.g., Adam [18] or AdamW [22]) without additional treatment.

3.2 Compressing Weights via BLAST Factorization

BLAST Factorization via Gradient Descent Given pre-trained dense weights of a DNN, we can compress the weights using BLAST matrices. Let A denote the weight matrix and A i,j denote its blocks. We estimate the BLAST factors of A i,j by finding the factors of the BLAST matrix that minimize the Frobenius norm error between the original weight matrix and the BLAST structure:

where ∗ denotes the collection of all b components along the axis. This problem shares many characteristics with the classical matrix factorization problem [23-26], and hence we can solve for the factors using alternating gradient descent starting from small random initialization (e.g., Line 1 of Algorithm 2) [27, 8]. That is, the k th gradient descent step is composed of three alternating updates with a step size η > 0 :

With properly chosen step sizes, Equations (5) to (7) always decrease the loss value whenever the current variables do not have any infinite entries and the gradient is non-zero. Using notations ¯ V ( k ) i = [ S ( k ) i, 1 V ( k ) T 1 · · · S ( k ) i,b V ( k ) T b ] T and ¯ U ( k ) j = [ ( U ( k +1) 1 S ( k ) 1 ,j ) T · · · ( U ( k +1) b S ( k ) b,j ) T ] T to indicate the concatenation of the right and left factors scaled by the diagonal components, the loss is monotonically non-increasing as in the following theorem.

Theorem 1. Let A i,j ∈ R p × p be a target block and U ( k ) i , V ( k ) j ∈ R p × r , and s ( k ) i,j ∈ R r be factors of a block in the BLAST matrix to be optimized. With the step sizes 0 < η U ( k ) i ≤ 1 /σ 1 ( ¯ V ( k ) T i ¯ V ( k ) i ) , 0 < η V ( k ) j ≤ 1 /σ 1 ( ¯ U ( k ) T j ¯ U ( k ) j ) , 0 < η s ( k ) i,j ≤ 1 /σ 1 ( ( U ( k +1) T i U ( k +1) i ) ⊙ ( V ( k +1) T j V ( k +1) j ) ) , the gradient descent updates in Equations (5) to (7) monotonically non-increase the loss:

The proof of Theorem 1 is in Section B, which is an application of the descent lemma from classical optimization theory.

Blast Factorization via Preconditioned Gradient Descent Recall that in order to estimate the BLAST factors given a pre-trained weight A , we need to choose a rank r . Since we do not know the rank of A a priori, we may have to overestimate the rank. However, overestimating the rank may slow down the convergence rate for solving Equation (4). To illustrate this, we performed an empirical analysis of the convergence behavior on a synthetically generated target low-rank matrix A , whose dimension is 256 × 256 with a true rank of r ∗ = 8 . For the analysis, we computed the factors of a BLAST matrix with b = 16 for various values of r . We used linearly decaying step sizes η ( k ) = η U ( k ) i = η V ( k ) j = η s ( k ) i,j . When r = r ∗ = 8 (the ranks of the left and right factors U ∗ , V ∗ match the actual rank of A ), gradient descent finds a low-rank solution with minimal error within 30 iterations, as shown by the blue curve in Figure 3-left. However, in the case of r = 32 > r ∗ where the BLAST factors are overparameterized, we observed slower convergence and a substantial residual

100

100

Error

10-1

PrecGD

Error

10-1

PrecGD

benius

10-2

10-2

Frol

b

10-3

10-3

izec

10-4

Normalized

10-5

10-4

10-6

10-5

10-7

0

20

40

60

80

100

0

20

40

60

80

100

Iterations

Iterations

Algorithm 2 Preconditioned BLAST Factorization (see Equations (8) and (9))

error after 100 steps as shown by the blue curve in Figure 3-right. This behavior is consistent with previous observations of slow convergence in ill-conditioned matrix factorization problems [23, 24].

The convergence rate of solving the overparameterized low-rank factorization by gradient descent can be improved via inexpensive preconditioners [23, 24] which effectively decrease the condition number at each iteration. Inspired by the preconditioned gradient descent for low-rank factorization, we generalize the idea to solve our problem by multiplying preconditioning matrices to the gradients in Equations (5) to (7). We summarize the preconditioned gradient descent method for the BLAST factorization in Algorithm 2, where the following preconditioning matrices are used:

δ is proportional to the square root of the error in Equation (4). The derivations are presented in Appendix A.2. Figure 3 shows that preconditioning improves the convergence of the overparameterized BLAST factorization. The preconditioned gradient descent (yellow curve) finds the points with low error after 100 steps, whereas the gradient descent without preconditioning fails to achieve a small error. More empirical studies on the BLAST factorization with or without preconditioning can be found in Appendix D.1. We summarize the compression procedure in Algorithm 2. The computational complexity of this compression algorithm is O ( nr 2 + r 3 ) where the cubic dependency on r is from the matrix inversion steps. We emphasize that these matrix inversion steps are not substantial computational bottlenecks because r is smaller than n as in prior work [23, 24].

After BLAST compression outlined in Algorithm 2, the BLAST factors can be used directly for inference to save both storage and computational costs. However, we observe that, instead of using the estimated factors directly, using them as initial points and refining the estimates by re-training the model with BLAST factors can further improve the performance of the compressed model. We refer to this process as 're-training' after BLAST compression.

0

.

2

0

.

3

0

.

4

0

.

5

Relative FLOPs

82

84

86

88

Accuracy (%)

ViT-S, CIFAR-10

0

.

2

0

.

3

0

.

4

0

.

5

0

.

6

Relative FLOPs

57

.

5

60

.

0

62

.

5

65

.

0

67

.

5

70

.

0

ViT-S, CIFAR-100

Dense

Low Rank

Monarch

Pixelfly

BLAST

3

4 Experimental Results

We evaluate the BLAST matrix under two settings: (i) training from scratch with random initialization in the BLAST format, and (ii) re-training after compressing the dense weights to BLAST matrices via Algorithm 2. We compare the performance of BLAST with both non-adaptive and adaptive structured matrices. Among the non-adaptive approaches, we include low-rank (LR) matrices, Monarch for block low-rank (BLR) [14], and Pixelfly [17] or Block-Diagonal for block sparse matrices. For the adaptive and learnable structured matrix category, we evaluate Gaudi-GBLR [12]. We report the number of floating point operations (FLOPs) by counting the number of multiplications. The BLAST matrix with b × b number of blocks is denoted by BLAST b . We used the same hyperparameter r for every target weight matrix by setting it to meet the computational budget of the DNN. All experimental details can be found in Appendix C.

4.1 Training from Scratch

Image Classification We train the reduced-size Vision Transformers (ViT) [19] with BLAST 3 (BLAST with b = 3 ) weight matrices on CIFAR-10, 100 [28], and ImageNet-1k[29] for 310 epochs from random initialization , and compare with other structured matrices. In the CIFAR-10 and CIFAR-100 benchmarks, BLAST outperforms several non-adaptive baselines, such as Low-Rank, Pixelfly, and Monarch with higher accuracy at the same FLOPs complexity (Figure 4). Gaudi-GBLR presents the most favorable accuracy-to-FLOPs tradeoff due to its capability of learning the adaptive resource/budget allocation for each weight matrix, which is a feature that our BLAST setting lacks in this particular evaluation (as we force it to use the same r for all matrices).

0

.

54

0

.

56

0

.

58

0

.

60

0

.

62

Relative FLOPs

20

.

0

20

.

5

21

.

0

21

.

5

22

.

0

22

.

5

23

.

0

Perplexity (

↓

)

Dense

LowRank

Block Diag

Monarch

BLAST

6

However, in the context of ImageNet-1k in Table 1, weight matrices trained using BLAST with b = 3 attain the highest levels of accuracy with the least FLOPs. This superior performance of BLAST (despite the common r for all matrices) over Gaudi-GBLR can be attributed to its simpler training process with fewer hyperparameters. In contrast, the more complex training requirements of Gaudi-GBLR, which involve smoothness annealing and proximal gradient descent, may lead to suboptimal results for a large model such as ViT-Base in Table 1.

Language Model Evaluation We validate the training performance of BLAST weights on language models. We replace the weights of GPT-2 [20] with random BLAST 6 matrices and trained the network from scratch on the WikiText 103 [30] dataset for 100 epochs. In Figure 5, we compare the test set perplexity of BLAST with the perplexity from low-rank, block-diagonal, Monarch, and Gaudi-GBLR matrices. Similar to the ImageNet training, we found that BLAST achieves the best perplexity-FLOPs trade-off. Compared to Gaudi-GBLR, BLAST obtains a significant perplexity gain. We attribute this

improvement to the simple training process of BLAST which requires less hyperparameter tuning than that of Gaudi-GBLR.

4.2 Compression and Re-training

In this section, we discuss the performance of BLAST weights when pre-trained dense weights are available. We first compress the dense weights using Algorithm 2 and re-train the model on the training data with the cross-entropy loss.

ViT on ImageNet Classification We compress the weights of the vision transformer (ViT) trained on ImageNet training set by BLAST 3 and BLAST 12 using Algorithm 2 and re-train the models for 35 epochs. The accuracy-FLOPs trade-off curve of each model is presented in Figure 6. Both BLAST compressed & re-trained models outperform other baselines, even though BLAST models did not use the adaptive budget allocation, unlike Gaudi-GBLR. It is observed that the accuracy of the BLAST models slightly increases from b = 3 to b = 12 .

Diffusion Models We compress the weights of a Diffusion Transformer (DiT) [13] pre-trained on ImageNet using BLAST matrices and compare its performance to SVD-based low-rank approximation. For both techniques, we match the compression ratio such that both decrease the total number of model parameters by 50%, and re-train each model for 10 epochs on the ImageNet training set. We evaluate the models by generating a total of 50,000 images using the original, low-rank, and BLAST compressed models, and compute the FID [31], sFID [32], and IS [33] metrics with respect to the ImageNet validation set. The objective is to observe if the compressed model can generate images as realistic as the original uncompressed model.

0

.

26

0

.

28

0

.

30

0

.

32

0

.

34

0

.

36

0

.

38

Relative FLOPs

74

75

76

77

78

79

ImageNet Accuracy (%)

Dense

Low Rank

Monarch

BLAST

3

BLAST

12

Table 2: Performance comparison for compressing the weight matrices of a diffusion model followed by re-training. FID and IS scores were computed with respect to a validation dataset. CR stands for Compression Ratio.

In Table 2, we show quantitatively that the model compressed via BLAST significantly outperforms the model compressed via SVD. The low-rank compressed model often generates unrealistic images, leading to poor metrics such as the inception score. Figure 1 also contrasts how the BLAST matrices contribute to maintaining high perceptual quality as well as a close instance-wise resemblance with the uncompressed model outputs. Due to space limitations, we defer additional qualitative results and experimental setup to Appendix D.2.

Large Language Models (LLMs) We compress the weights of Llama-7B [1] with BLAST matrices using Algorithm 2 by 20% and 50%, and re-train the models for 400 steps on a subset of SlimPajama [34] dataset using 0.49B tokens. The number of blocks b in the BLAST matrices is fixed at 16, and we use r = 1024 for the attention modules and r = 1488 for the MLP modules to achieve a 50% compression ratio. We test the WikiText-2 perplexity and the zero-shot task classification accuracy on common sense reasoning datasets including PIQA[35], HellaSwag[36], WinoGrande[37], BoolQ[38], OpenBookQA[39], ARC-easy and challenge [40]. We report the performance of Low-Rank, Monarch, and Block-Diagonal weight matrices after compression at the same rate and re-training. In Table 3, the first row presents the performance of the original Llama-7B model. On 50% compression ratio in the last five rows, the Monarch and Block-Diagonal matrices fail to recover the acceptable performance. Compared to Low-Rank weights, BLAST weights achieve the lowest performance degradation in WikiText-2 perplexity and zero-shot classification accuracy. The accuracy of each common sense reasoning benchmark and extended results can be found in Appendix D.3.

We provide an analysis to quantify the performance impact of compression and re-training. We first quantify the weight compression performance at 20% compression ratio in Table 3. Although the compression ratio is moderate, Low-Rank and Monarch compression without re-training suffer from

0

10

20

30

40

50

Compression Ratio (%)

50

55

60

65

Zero-shot Accuracy (%)

Llama-7B, Avg. Zero-shot Accuracy

Uncompressed

BLAST

16

(Comp. Only)

BLAST

16

(Comp.+Retrain)

significant performance loss, at most 4x higher perplexity and 25% accuracy degradation. On the other hand, BLAST 16 compression without re-training maintains reasonable accuracy and perplexity. This shows that the flexible and adaptive structure of BLAST matrices captures more information than other types of structured matrices. Yet, BLAST compression also exhibits noticeable performance degradation on a more intensive compression ratio (see the yellow curve in Figure 7). We provide more compression-only results on Diffusion Models and LLMs in Appendix D.

We find that the re-training stage is crucial for converting a pre-trained model into an efficient version without losing significant accuracy when the compression ratio is high. In Figure 7, we show the average zero-shot classification accuracy of the compressed models with 50% compression. The models with BLAST weights before re-training (yellow curve) exhibit substantial accuracy degradation at higher compression ratios. However, re-training (blue curve) effectively recovers performance using only 0.49B tokens and 400 steps.

LLM Runtime Analysis We evaluate the runtime of the Llama-7B compressed by the BLAST matrices on the text generation task. For evaluation, we let the model generate the sequences of length L = 10, 100, and 1000 ten times and report the average and the standard deviation of model runtime in Table 4. The instruction we use to generate the desired sequence length is ' Increasing sequence: one, ' and the model generates the text sequence such as ' two, three, ' and so on, with a batch size of 1. All runtime evaluation tests were conducted on a single 40GB NVIDIA A100 GPU after compiling the script using torch.compile() . The 20% compressed model shows a 12% ∼ 15% runtime reduction without any library function customization for BLAST matrix multiplication. The speedup when b = 2 is higher than when b = 16 because a larger number of blocks increases the computation overhead to perform Equation (3). Notably, the 50% compression ratio provides 32% ∼ 35% runtime reduction when b = 16 . We note that the test is highly memory-bandwidthbounded. Thus the speedup reported in Table 4 can be mostly attributed to the reduction of parameters (i.e., memory accesses) rather than the reduction in FLOPs due to BLAST compression.

5 Related Works

Structured Matrix with Shared Bases Sharing the bases of block-structured matrices has recently drawn interest due to its considerable memory savings. BLAST matrices exemplify this approach.

Ashcraft et al. [41] extend the BLR [15] format to BLR 2 , incorporating shared bases and block-wise low-rank coupling factors determined through LQ or QR factorization. Similarly, Yen et al. [42] apply the concept of shared bases in the Block-Diagonal preconditioner for DNN weights. While BLAST also shares the bases of blocks, it is distinct in having a diagonal coupling matrix, as shown in Equation (2). The design of BLAST matrices aims to enhance efficiency and learn a variety of structures, from low-rank to high-rank block matrices. More importantly, identifying the diagonal coupling factors in BLAST matrices does not necessitate QR decomposition. Instead, they can be updated via gradient descent, making this approach well-suited for modeling the weight matrices in deep learning models.

DNN Weight Pruning and Decomposition Earlier work on DNN pruning [43-45] identifies less important parameters from the Hessian or magnitude to sparsify the weight matrix. Unlike general sparse matrices, a group sparse matrix skips computation in a group-wise manner by pruning channels [46, 47]. Sparse GPT [11] successfully prunes large language models with 50% sparsity without significantly degrading the performance of the original model. The model can achieve actual speedup utilizing 2:4 sparsity [48] on specific GPUs. However, 2:4 sparsity requires accelerators with specific architectures (e.g., NVIDIA A100 GPUs) and supports only the 50% compression ratio. On the other hand, BLAST is device-agnostic since it can be implemented with basic matrix arithmetic operations and offers diverse compression ratios.

Low-rank matrices have been widely adopted for CNN compression [49, 50] and Transformer compression [51, 52]. Additionally, Butterfly [53] and Monarch [14] factorization methods model high-rank but low-dimensional structures of the weights. Specifically, a Monarch matrix is a generalized version of a Butterfly matrix, yielding a wider spectrum of structured matrices. The number of blocks plays a key role in determining the rank of the Monarch matrix as a whole and does not generalize to another Monarch matrix with fewer blocks. Unlike Monarch, BLAST with b × b blocks can express Monarch matrices with the same or fewer number of blocks, including the global low-rank matrix, i.e., b = 1 .

Learning Low-dimensional Structures of DNN Weights Similar to the BLAST matrix, a GaudiGBLR matrix [12] enables learning low-dimensional structures by gradient descent in the generalized structured matrix space. Gaudi-GBLR overlaps a variable number of zero-padded rank-1 blocks to model high-rank submatrices. Although Gaudi-GBLR can express a wider spectrum of matrices than BLAST, the matrix-vector multiplication for Gaudi-GBLR is less efficient because GPUs and typical neural processors cannot handle zero-padded vectors efficiently. In contrast, the BLAST matrix-vector operation does not involve zero padding, allowing for more efficient execution in hardware for the same FLOPs (as shown in Figure 4, Figure 6, and Table 1).

6 Conclusion and Future Work

In this work, we introduced the BLAST matrix designed to improve the inference efficiency of large DNNs. The BLAST matrix represents various low-dimensional structures of the weight matrices with fewer parameters, while enabling efficient matrix-vector products. The BLAST factors are either learnable from data or estimated from existing weights using our preconditioned factorization algorithm. Our results on both language and vision tasks highlight the effectiveness of BLAST.

Limitations and Future Work The BLAST matrix-vector product consists of three steps, as detailed in Equation (3), which may degrade hardware-execution parallelism. In our evaluation, we used the same computational budget r for all matrices. Learning an adaptive budget per layer or matrix (e.g., via overparameterization [54, 7]) could further improve BLAST performance, which is left for future work. The proposed method has not been evaluated on tiny (<100M parameters) or extremely large (>10B parameters) DNNs. Additionally, optimizing runtime and power consumption via BLAST matrices with customized library functions and/or hardware accelerators also remains as future work. Furthermore, a deeper theoretical investigation into the behaviors of BLAST matrices would provide a more comprehensive understanding of their capabilities and limitations. Applying advanced re-training techniques, such as knowledge distillation [55] or iterative compression and distillation [56], to the BLAST compression pipeline is also left for future work. Finally, beyond the weight structures, we expect BLAST can also help understand and exploit low-dimensional data manifolds [57-59] in future work.

Acknowledgments and Disclosure of Funding

The arXiv version of the paper can be found at https://arxiv.org/abs/2410.21262 . This work was supported in part by COGNISENSE, one of seven centers in JUMP 2.0, a Semiconductor Research Corporation (SRC) program sponsored by DARPA. SMK and QQ acknowledge funding support from NSF CAREER CCF-2143904, and NSF CCF-2212066. We thank Salar Fattahi, Reetuparna Das, Mingyu Yang, Sara Shoouri, Shrikant Arvavasu, Jayeon Yi, Andrew Larson, Pierre Abillama, Alireza Khadem, Yufeng Gu, and Can Yaras for helpful discussion and feedback.

References

Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971 , 2023.

Alexander Kirillov, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chloe Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead, Alexander C Berg, Wan-Yen Lo, et al. Segment anything. In Proceedings of the IEEE/CVF International Conference on Computer Vision , pages 4015-4026, 2023.

Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. Highresolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , pages 10684-10695, 2022.

Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 , 2023.

Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning , pages 8748-8763. PMLR, 2021.

Minyoung Huh, Hossein Mobahi, Richard Zhang, Brian Cheung, Pulkit Agrawal, and Phillip Isola. The low-rank simplicity bias in deep networks. Transactions on Machine Learning Research , 2022.

Can Yaras, Peng Wang, Wei Hu, Zhihui Zhu, Laura Balzano, and Qing Qu. The law of parsimony in gradient descent for learning deep linear networks. arXiv preprint arXiv:2306.01154 , 2023.

Soo Min Kwon, Zekai Zhang, Dogyoon Song, Laura Balzano, and Qing Qu. Efficient lowdimensional compression of overparameterized models. In Sanjoy Dasgupta, Stephan Mandt, and Yingzhen Li, editors, Proceedings of The 27th International Conference on Artificial Intelligence and Statistics , volume 238 of Proceedings of Machine Learning Research , pages 1009-1017. PMLR, 02-04 May 2024. URL https://proceedings.mlr.press/v238/ min-kwon24a.html .

Peng Wang, Xiao Li, Can Yaras, Zhihui Zhu, Laura Balzano, Wei Hu, and Qing Qu. Understanding deep representation learning via layerwise feature compression and discrimination. arXiv preprint arXiv:2311.02960 , 2023.

Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations , 2019. URL https://openreview.net/forum?id=rJl-b3RcF7 .

Elias Frantar and Dan Alistarh. Sparsegpt: Massive language models can be accurately pruned in one-shot. In International Conference on Machine Learning , pages 10323-10337. PMLR, 2023.

Changwoo Lee and Hun-Seok Kim. Differentiable learning of generalized structured matrices for efficient deep neural networks. In The Twelfth International Conference on Learning Representations , 2024. URL https://openreview.net/forum?id=pAVJKp3Dvn .

William Peebles and Saining Xie. Scalable diffusion models with transformers. In Proceedings of the IEEE/CVF International Conference on Computer Vision , pages 4195-4205, 2023.

Tri Dao, Beidi Chen, Nimit S Sohoni, Arjun Desai, Michael Poli, Jessica Grogan, Alexander Liu, Aniruddh Rao, Atri Rudra, and Christopher Ré. Monarch: Expressive structured matrices for efficient and accurate training. In International Conference on Machine Learning , pages 4690-4721. PMLR, 2022.

Patrick Amestoy, Cleve Ashcraft, Olivier Boiteau, Alfredo Buttari, Jean-Yves L'Excellent, and Clément Weisbecker. Improving multifrontal methods by means of block low-rank representations. SIAM Journal on Scientific Computing , 37(3):A1451-A1474, 2015.

Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems , 30, 2017.

Beidi Chen, Tri Dao, Kaizhao Liang, Jiaming Yang, Zhao Song, Atri Rudra, and Christopher Re. Pixelated butterfly: Simple and efficient sparse training for neural network models. In International Conference on Learning Representations , 2022. URL https://openreview. net/forum?id=Nfl-iXa-y7R .

Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980 , 2014.

Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations , 2020.

Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog , 1(8):9, 2019.

Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. Advances in neural information processing systems , 32, 2019.

Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations , 2019. URL https://openreview.net/forum? id=Bkg6RiCqY7 .

Tian Tong, Cong Ma, and Yuejie Chi. Accelerating ill-conditioned low-rank matrix estimation via scaled gradient descent. Journal of Machine Learning Research , 22(150):1-63, 2021.

Jialun Zhang, Salar Fattahi, and Richard Y Zhang. Preconditioned gradient descent for overparameterized nonconvex matrix factorization. Advances in Neural Information Processing Systems , 34:5985-5996, 2021.

Xingyu Xu, Yandi Shen, Yuejie Chi, and Cong Ma. The power of preconditioning in overparameterized low-rank matrix sensing. In International Conference on Machine Learning , pages 38611-38654. PMLR, 2023.

Tian Ye and Simon S Du. Global convergence of gradient descent for asymmetric low-rank matrix factorization. Advances in Neural Information Processing Systems , 34:1429-1439, 2021.

Dominik Stöger and Mahdi Soltanolkotabi. Small random initialization is akin to spectral learning: Optimization and generalization guarantees for overparameterized low-rank matrix reconstruction. Advances in Neural Information Processing Systems , 34:23831-23843, 2021.

Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical Report 0, University of Toronto, Toronto, Ontario, 2009. URL https://www.cs. toronto.edu/~kriz/learning-features-2009-TR.pdf .

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-252, 2015. doi: 10.1007/s11263-015-0816-y.

Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843 , 2016.

Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems , 30, 2017.

Charlie Nash, Jacob Menick, Sander Dieleman, and Peter Battaglia. Generating images with sparse representations. In International Conference on Machine Learning , pages 7958-7968. PMLR, 2021.

Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. Advances in neural information processing systems , 29, 2016.

Daria Soboleva, Faisal Al-Khateeb, Robert Myers, Jacob R Steeves, Joel Hestness, and Nolan Dey. SlimPajama: A 627B token cleaned and deduplicated version of RedPajama. https://www.cerebras.net/blog/ slimpajama-a-627b-token-cleaned-and-deduplicated-version-of-redpajama , 2023. URL https://huggingface.co/datasets/cerebras/SlimPajama-627B .

Yonatan Bisk, Rowan Zellers, Jianfeng Gao, Yejin Choi, et al. Piqa: Reasoning about physical commonsense in natural language. In Proceedings of the AAAI conference on artificial intelligence , volume 34, pages 7432-7439, 2020.

Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. Hellaswag: Can a machine really finish your sentence? In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics , 2019.

Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale. Communications of the ACM , 64(9):99-106, 2021.

Christopher Clark, Kenton Lee, Ming-Wei Chang, Tom Kwiatkowski, Michael Collins, and Kristina Toutanova. Boolq: Exploring the surprising difficulty of natural yes/no questions. arXiv preprint arXiv:1905.10044 , 2019.

Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. Can a suit of armor conduct electricity? a new dataset for open book question answering. arXiv preprint arXiv:1809.02789 , 2018.

Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge. arXiv preprint arXiv:1803.05457 , 2018.

Cleve Ashcraft, Alfredo Buttari, and Theo Mary. Block low-rank matrices with shared bases: Potential and limitations of the blr ˆ2 format. SIAM Journal on Matrix Analysis and Applications , 42(2):990-1010, 2021.

Jui-Nan Yen, Sai Surya Duvvuri, Inderjit S Dhillon, and Cho-Jui Hsieh. Block low-rank preconditioner with shared basis for stochastic optimization. In Thirty-seventh Conference on Neural Information Processing Systems , 2023. URL https://openreview.net/forum?id= JzQlGqBm8d .

Yann LeCun, John Denker, and Sara Solla. Optimal brain damage. Advances in neural information processing systems , 2, 1989.

Babak Hassibi and David Stork. Second order derivatives for network pruning: Optimal brain surgeon. Advances in neural information processing systems , 5, 1992.

Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In Yoshua Bengio and Yann LeCun, editors, 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings , 2016. URL http://arxiv. org/abs/1510.00149 .

Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE international conference on computer vision , pages 1389-1397, 2017.

Xinyin Ma, Gongfan Fang, and Xinchao Wang. Llm-pruner: On the structural pruning of large language models. Advances in neural information processing systems , 36:21702-21720, 2023.

Asit Mishra, Jorge Albericio Latorre, Jeff Pool, Darko Stosic, Dusan Stosic, Ganesh Venkatesh, Chong Yu, and Paulius Micikevicius. Accelerating sparse deep neural networks. arXiv preprint arXiv:2104.08378 , 2021.

Cheng Tai, Tong Xiao, Xiaogang Wang, and Weinan E. Convolutional neural networks with lowrank regularization. In Yoshua Bengio and Yann LeCun, editors, 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings , 2016. URL http://arxiv.org/abs/1511.06067 .

Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. arXiv preprint arXiv:1405.3866 , 2014.

Edward J Hu, yelong shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-rank adaptation of large language models. In International Conference on Learning Representations , 2022. URL https://openreview. net/forum?id=nZeVKeeFYf9 .

Habib Hajimolahoseini, Walid Ahmed, Mehdi Rezagholizadeh, Vahid Partovinia, and Yang Liu. Strategies for applying low rank decomposition to transformer-based models. In 36th Conference on Neural Information Processing Systems (NeurIPS2022) , 2022.

Tri Dao, Albert Gu, Matthew Eichhorn, Atri Rudra, and Christopher Ré. Learning fast algorithms for linear transforms using butterfly factorizations. In International conference on machine learning , pages 1517-1527. PMLR, 2019.

Can Yaras, Peng Wang, Laura Balzano, and Qing Qu. Compressible dynamics in deep overparameterized low-rank learning & adaptation. In Forty-first International Conference on Machine Learning , 2024.

Geoffrey Hinton. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531 , 2015.

Sharath Turuvekere Sreenivas, Saurav Muralidharan, Raviraj Joshi, Marcin Chochowski, Mostofa Patwary, Mohammad Shoeybi, Bryan Catanzaro, Jan Kautz, and Pavlo Molchanov. Llm pruning and distillation in practice: The minitron approach. arXiv preprint arXiv:2408.11796 , 2024.

Peng Wang, Huijie Zhang, Zekai Zhang, Siyi Chen, Yi Ma, and Qing Qu. Diffusion models learn low-dimensional distributions via subspace clustering. arXiv preprint arXiv:2409.02426 , 2024.

Gen Li and Yuling Yan. Adapting to unknown low-dimensional structures in score-based diffusion models. arXiv preprint arXiv:2405.14861 , 2024.

Siyi Chen, Huijie Zhang, Minzhe Guo, Yifu Lu, Peng Wang, and Qing Qu. Exploring lowdimensional subspace in diffusion models for controllable image editing. In The Thirtyeighth Annual Conference on Neural Information Processing Systems , 2024. URL https: //arxiv.org/abs/2409.02374 .

Roger A Horn and Charles R Johnson. Matrix analysis . Cambridge university press, 2012.

Sébastien Bubeck et al. Convex optimization: Algorithms and complexity. Foundations and Trends® in Machine Learning , 8(3-4):231-357, 2015.

Roger A Horn and Charles R Johnson. Topics in matrix analysis . Cambridge university press, 1994.

Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501 , 2018.

Ethan Perez, Florian Strub, Harm De Vries, Vincent Dumoulin, and Aaron Courville. Film: Visual reasoning with a general conditioning layer. In Proceedings of the AAAI conference on artificial intelligence , volume 32, 2018.

Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in neural information processing systems , 33:6840-6851, 2020.

Runyu Peng, Yunhua Zhou, Qipeng Guo, Yang Gao, Hang Yan, Xipeng Qiu, and Dahua Lin. Data-freeweight compress and denoise for large language models. arXiv preprint arXiv:2402.16319 , 2024.

Leo Gao, Jonathan Tow, Baber Abbasi, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence Golding, Jeffrey Hsu, Alain Le Noac'h, Haonan Li, Kyle McDonell, Niklas Muennighoff, Chris Ociepa, Jason Phang, Laria Reynolds, Hailey Schoelkopf, Aviya Skowron, Lintang Sutawika, Eric Tang, Anish Thite, Ben Wang, Kevin Wang, and Andy Zou. A framework for few-shot language model evaluation, 12 2023. URL https://zenodo.org/records/ 10256836 .

A Details on BLAST Matrix and Factorization

Matrix Multiplication Code Implementation Following the conventional setting in Transformers [16], the input tensor is assumed to have batch, sequence, and channel dimensions. The left and right factors are multiplied using the batched matrix multiplication routine, whereas the diagonal factors are multiplied via broadcasting and summation.

A.1 More Special Cases of BLAST Matrix

Block diagonal matrix A block-diagonal matrix is a BLAST matrix when r = p and s i,j =

When r < p , BLAST matrices model block-diagonal matrices which have low-rank diagonal blocks.

Block low-rank (BLR) matrix For ease of understanding, let us consider a BLR matrix of 9 n 3 × n 3 rank-1 blocks. Each block is composed of the unique bases A i,j = u i,j v T i,j . Now consider U i = [ u i, 1 , u i, 2 , u i, 3 ] and V j = [ v 1 ,j , v 2 ,j , v 3 ,j ] . Then, the BLR matrix is a BLAST matrix with r = b = 3 :

where S 1 = diag([1 , 0 , 0]) , S 2 = diag([0 , 1 , 0]) , and S 3 = diag([0 , 0 , 1]) .

To model a n × n general b × b partitioned BLR matrix where the rank of each block is t , let us use the BLAST matrix with b × b blocks and r = bt . The factors have the following shapes:

By letting s i,j,k = { 1 if t ( j -1) + 1 ≤ k < tj +1 0 otherwise , the BLAST matrix can model the BLR matrix.

Note that the number of parameters of the BLAST matrix is 2 nr + rb 2 , whereas that of the BLR matrix in this case is b 2 · ( p + p ) t = 2( pb )( bt ) = 2 nr . In other words, the BLAST matrix models various matrices with the cost of rb 2 .

A.2 Derivation of Preconditioning Matrices

We rewrite the loss function in Equation (4) below:

We first derive the gradients of U i , V j , and s i,j , then discuss the preconditioning matrix for each factor.

A.2.1 Gradients

Here we derive the gradients of Equation (4) with respect to the BLAST factors. We begin with introducing the short-handed notation for the concatenated factors:

That is, the matrix ¯ V i is composed by concatenating V T j s horizontally along j = 1 , 2 , . . . , b after scaling them with S i,j . ¯ U j is defined similarly by concatenating the scaled U i s vertically. Now we derive the gradients below.

Gradient of U i We only have to consider the loss term related to U i . Therefore, we have the following gradient expression:

where for the second equality we used the concatenated version of the first line.

Gradient of V j follows the similar derivation as Equation (10):

Gradient of s i,j We consider the block-wise loss for the gradient:

Since the Frobenius norm can be expressed by a matrix trace, the loss is written as follows:

where Tr( X ) is the trace of X . Note that the derivative of product in trace is given by ∇ X Tr( XY ) = Y T for any two conformal matrices X and Y . Therefore, we have

Now Equation (12) becomes as follows:

The first term on the right hand side is further arranged by using the fact that diag ( XY T ) = ( X ⊙ Y ) 1 for any two matrices X , Y of the same size.

Hence, the gradient of s i,j is now expressed as follows:

A.2.2 Preconditioning Matrices

Now let us derive the preconditioning matrices used in Algorithm 2.

Preconditioning matrix P U i for U i Let V j and s i,j are given. Let us consider the case when U i is at the stationary point ˆ U which satisfies

where O is the zero matrix. This gives us the normal equation

Now consider a preconditioned gradient descent with P U i ∈ R r × r :

Suppose ¯ V T i ¯ V i is invertible. Then the ideal preconditioner is

since it brings U ′ i to the stationary point ˆ U . However, directly use the inverse of ¯ V T i ¯ V might result in numerical instability or complete breakdown of the algorithm when the matrix is singular. By following [24], we use the regularized version

Preconditioning matrix P V j for V j The preconditioner for V j can be derived by following the similar steps for P U i . Here we present the result:

where δ is chosen by where δ is chosen by Equation (19).

Preconditioning matrix P s i,j for s i,j We again consider the stationary point ˆ s or the diagonal version ˆ S = diag(ˆ s ) which has a zero gradient:

Therefore, Equation (15) can be written as follows:

Now consider the preconditioned gradient descent:

The Hadamard product of two positive definite matrices are still positive definite (see [60, Theorem 7.5.3], also known as Schur's Product Theorem). Hence, if both U T i U i and V T j V j are positive definite so that invertible, ( U T i U i ) ⊙ ( V T j V j ) is also invertible. The ideal preconditioner when both matrices are invertible is therefore

Same as for P U i and P V j , we also consider the regularized version:

Here, δ is chosen by Equation (19).

B Proof of Theorem 1

We first introduce the following properties:

Lemma 2. [61, Lemma 3.4] Assume f : R n → R is convex and continuously differentiable, and its gradient is L -Lipschitz continuous. Then for any x , y ∈ R n , one has

Proof. See [61, Lemma 3.4].

Lemma 3. Assume f : R n → R is convex and continuously differentiable, and its gradient is L -Lipschitz continuous. Consider a gradient descent update

Then, with the step size 0 < η ≤ 1 L , the following holds:

That is, the gradient descent update does not increase the function value.

Now we prove Theorem 1, which we restate below.

Theorem 1. Let A i,j ∈ R p × p be a target block and U ( k ) i , V ( k ) j ∈ R p × r , and s ( k ) i,j ∈ R r be factors of a block in the BLAST matrix to be optimized. With the step sizes 0 < η U ( k ) i ≤ 1 /σ 1 ( ¯ V ( k ) T i ¯ V ( k ) i ) , 0 < η V ( k ) j ≤ 1 /σ 1 ( ¯ U ( k ) T j ¯ U ( k ) j ) , 0 < η s ( k ) i,j ≤ 1 /σ 1 ( ( U ( k +1) T i U ( k +1) i ) ⊙ ( V ( k +1) T j V ( k +1) j ) ) , the gradient descent updates in Equations (5) to (7) monotonically non-increase the loss:

Proof. To prove Theorem 1, we first show that each step of Equations (5) to (7) satisfies Lemma 3 under the given conditions. Then we resemble the results to construct the bound.

Gradient Descent Update on U i Let us denote the loss term regarding U i by

Since (i) the Frobenius norm is convex, (ii) all linear mappings are convex, and (iii) a composition of two convex functions are convex, ∥ ∥ A i, ∗ -U i ¯ V T i ∥ ∥ 2 F is a convex function of U i . Also, the gradient we derived in Equation (10) always exists and has the following vectorized form:

where ⊗ denotes the Kronecker product and u i = vec( U i ) . The Lipschitz constant of the gradient is the largest singular value of the matrix ( ¯ V T i ¯ V i ) T ⊗ I , which is the largest singular value of ¯ V T i ¯ V i since the Kronecker product of two matrices of singular values Σ 1 and Σ 2 has the singular values of Σ 1 ⊗ Σ 2 (see [62, Theorem 4.2.15]).

Therefore, from Lemma 3, we obtain the following bound:

Gradient Descent Update on V j The loss function ℓ ( V j ) = 1 2 ∥ A ∗ ,j -¯ U j ¯ U T j ∥ 2 F with respect to V j is convex to V j and the gradient of V j in Equation (11) also always exists and can be rewritten as follows:

The Lipschitz constant of the gradient is again the largest singular value of ¯ U T j ¯ U j . We have the bound from Lemma 3 similar to Equation (23):

Gradient Descent Update on s i,j The loss function

is also convex in s i,j since diag( · ) is a convex mapping. We know the gradient exists from Equation (15):

and the Lipschitz constant of the gradient is σ 1 (( U T i U i ) ⊙ ( V T j V j )) . The bound from Lemma 3 for the diagonal factors is as follows:

Combining Equations (23) to (25), we retrieve the bound in Theorem 1:

C Experimental Details

In this section, we provide the experimental details. Throughout the experiments, we used 8 NVIDIA A40 GPUs or 4 NVIDIA L40S GPUs for training and evaluation, and a single NVIDIA A100 GPU with 40GB memory for runtime evaluation.

C.1 Datasets and Benchmarks

Image Datasets For image classification tasks, we use CIFAR-10 [28], CIFAR-100 [28], and ImageNet-1k [29] datasets for our experiments. CIFAR-10 and 100 contain 50,000 training and 10,000 test images, each of which is 32 × 32 color images of 10 and 100 classes, respectively. ImageNet-1k consists of 1,281,167 training and 50,000 validation images of 1,000 classes.

Common Sense Reasoning Benchmarks For our large language model evaluation, we use the following common sense reasoning benchmarks: Physical Interaction: Question Answering (PIQA) [35], HellaSwag[36], WinoGrande[37], BoolQ[38], OpenBookQA[39], AI2's Reasoning Challenge (ARC)-easy and challenge [40]. PIQA targets the task of physical common sense reasoning, with 16,000 examples for training, 2,000 for development, and 3,000 for testing. HellaSwag is composed of 10k questions that are specifically hard for the machines, though trivial for humans (95% accuracy). Winogrande is a large-scale dataset of 44k pronoun resolution problems. BoolQ consists of 15,942 yes/no questions. OpenBookQA is modeled after open book exams for assessing human understanding of a subject, containing 5,957 multiple-choice elementary-level science questions (4,957 train, 500 dev, 500 test). AI2's Reasoning Challenge (ARC) dataset consists of 7,787 multiple-choice science exam questions, and the questions are categorized into 'easy' and 'challenging' subsets.

C.2 CIFAR-10/100 and ImageNet-1k Image Classification Training

For CIFAR-10 and CIFAR-100 training, we trained the ViT-Small models with 4 × 4 -sized patches [19]. We trained ViT-Base models with 16 × 16 -sized patches for ImageNet-1k training. All models were trained by the AdamW [22] optimizer.

In the ViT models, we replaced the weight matrices of query, key, and value projection layers in one attention module and those in the feed-forward modules. In addition, we stacked the weights of query, key, and value weights and modeled them by one BLAST matrix.

The BLAST factors were randomly initialized to have the desired standard deviation σ = 0 . 02 while having zero-mean, where the standard deviation 0 . 02 was also used for initializing the weights of the original-sized ViTs. Specifically, we initialized the factors as follows:

where Unif(0 . 0 , 2 . 0) denotes a uniform distribution on the interval [0 , 2] .

For all models, we applied AutoAugment [63]. We summarize the training hyperparameters in Table 5.

C.3 Compression and Re-training

ViT on ImageNet-1k For ImageNet-1k compression and re-training, we followed a similar strategy to the ImageNet training with minor changes, summarized in Table 6. The ViT-Base with 16 × 16 -sized patches was chosen as a baseline model. We decomposed the pre-trained weight matrices of ViT-Base by Algorithm 2 with K = 300 and δ 0 = 0 . 1 . Also, we linearly decayed the step size from 1.0 to 0.0. Then, all compressed models were trained by the AdamW [22] optimizer.

Diffusion Model We compressed the DiT-XL model with 2 × 2 -sized patches [13], pre-trained on the 256 × 256 ImageNet training samples. A DiT model is a variant of Vision Transformer [19] with additional adaptive layer normalization (adaLN) [64]. Here, we compressed the stacked query, key, and value weights, the first fully connected layer of the feed-forward module, and the adaLN projection layers by BLAST 9 or low-rank matrices. All weights were compressed by Algorithm 2 with K = 500 and δ 0 = 0 . 1 . We linearly decayed the step size from 1.0 to 0.0. The parameters of the BLAST and the low-rank matrices were set to have the desired compression ratio in total, i.e., we remove 50% (or 20%) of the total parameters out of the network. We present the summary in Tables 7 and 8. We generated 50,000 images using the original, the low-rank-compressed, and the BLAST-compressed DiT.

FID, sFID and IS Evaluation We sampled the novel images using DDPM sampler [65] for FID, sFID, and IS evaluation in Table 2. The step size was set to 250 for each model. Then, the FID, sFID, and IS were computed between each pool of generated images and the 50,000 ImageNet validation images to estimate the distributional discrepancy between the target and the generated samples.

Large Language Model For the large language model compression, we used the Llama-7B pretrained model, publicly available at https://huggingface.co/huggyllama/llama-7b . For the 50% compression ratio, we compressed all the weights in the main modules of Llama-7B with BLAST with the parameters described in Table 9. For the 20% and 10% compression ratios, we compressed the weights of Q_proj, K_proj, gate_proj, up_proj layers to match the target compression ratio of the total parameter counts. Also, by following [66], we compress Q_proj and K_proj layers for the first 10 attention modules. The parameters used in the experiment are summarized in Tables 8, 9 and 11. All weights were compressed by Algorithm 2 with K = 300 and

δ 0 = 0 . 1 . We linearly decayed the step size from 1.0 to 0.0. The factorization process takes 3.38 GPU hours for the BLAST weights of b = 16 on NVIDIA A40 GPUs.

To re-train the compressed Llama models, we used a subset 2 of the SlimPajama dataset [34] for 400 steps using 0.47B tokens. The global batch size was set to 576, and the models were trained on 4 NVIDIA L40S GPUs. See Table 6 for details.

We used Language Model Evaluation Harness 3 [67] for the zero-shot classification accuracy evaluation.

D Additional Experimental Results

D.1 Synthetic Experiments on BLAST Factorization

In this experiment, we test the factorization algorithms discussed in Section 3, similar to Figure 3 but with a different target matrix. To be specific, we synthesize a 256 × 256 -sized BLAST 16 (i.e., b = 16 ) target matrix with r ∗ = 8 . Then, we compare the error curve along the iterates of the gradient descent without preconditioning (GD) in Equations (5) to (7), and the preconditioned gradient descent (PrecGD) in Algorithm 2. Here, we consider the exact parameterization setting when r = r ∗ = 8 and the over-parameterized setting r = 32 > r ∗ . In Figure 9, unlike the low-rank target matrix, GD does not converge in both cases. However, the preconditioned version easily finds the low-error solution for the exact parameterization. For the overparameterized case, the preconditioned gradient descent method in Algorithm 2 achieved in two orders of magnitude improvement from the simple GD.

100

100

10-1

PrecGD

PrecGD

10-2

10-1

10-3

10-4

10-2

10-5

10-6

10-3

10-7

0

20

40

60

80

100

0

20

40

60

80

100

Iterations

Iterations

BLAST

→

BLAST.

Original

Low-Rank

BLAST

D.2 Additional Results on Diffusion Model Compression

We include extended experimental results of the diffusion model compression in Section 4.2

Compression-only In Figures 10 and 11, the additional image samples of original uncompressed, low-rank-compressed, and BLAST 9 -compressed DiT [13] models are presented. The images in the same column were sampled using 250 DDIM steps, starting from the same noise vector. The compression ratio was set to 20% for both models. The figures show that the outputs of the model compressed by BLAST maintain similar features and perceptual quality to the outputs of the original DiT.

Compression and re-training We present additional samples from the low-rank and BLAST DiT models at the 50% compression ratio after re-training in Figure 13. Similar to Figure 1, the images generated by the low-rank DiT lose significant image quality, whereas the images from the BLAST DiT preserve the quality and semantics of the original samples.

Original

Low-Rank

BLAST

BLAST

Low-Rank

68.

6a

Evidence of low performance of low-rank-compressed model Some images generated by the 20% low-rank-compressed model (Figure 12-left) are highly unrealistic and have inferior quality compared to the images generated by original and BLAST-compressed models (Figure 12-right). We observe that these samples contribute to the low scores in Table 2. These samples were computed using 250 DDPM steps, as done by the original DiT work [13].

D.3 Additional Results on Large Language Model Compression

Compression-only We report the performance of LLM-Pruner [47] and Joint Rankk [66] for the same compression task. LLM-Pruner [47] identifies sparse weights with data to pinpoint unimportant neurons. Joint Rankk [66] performs a low-rank approximation jointly on weight matrices with similar column spaces by stacking them and applying a truncated SVD.

In Table 12, we compare the performance degradation of LLM-Pruner, Joint Rankk , Low-Rank, BLAST 2 , and BLAST 16 , as well as their absolute performance. The first four rows represent the zero-shot performance of Llama-7B [1] from the literature, while the row marked with an asterisk ( ∗ ) indicates our results.

For 10% compression, Joint Rankk achieved the lowest performance degradation, although BLAST 16 also exhibited a similar performance drop. When the model is compressed by 20%, BLAST 16 surpasses Joint Rankk [66], LLM-Pruner [47], and low-rank schemes. The zero-shot accuracy versus compression ratio curve in Figure 7 shows that BLAST compression results in less performance drop for the same compression ratio.

Original

Low-Rank

BLAST

ER

BR.

区

中

Rh

EQ8

RD

Compression and Re-training In Table 13, we present the performance of each common sense reasoning benchmark which we report their average in Table 3.

E Broader Impact

Our proposed method targets improving the efficiency of the DNN inference. This might have a negative social impact by promoting the accessibility and usability of malicious DNNs such as DeepFake. However, at the same time, we expect the BLAST matrix will bring a tremendous positive social impact. First, it contributes to sustainability by cutting down the energy consumption for the DNN inference. Moreover, the BLAST matrix can improve the accessibility of AI-based medical, educational, and social services by providing a foundation for running those models on mobile devices. Therefore, we believe BLAST will give tangible benefits to our society.

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: Section 1.

Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper.

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: Section 6

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: Section 3 and B.

Guidelines:

The answer NA means that the paper does not include theoretical results.

All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced.

All assumptions should be clearly stated or referenced in the statement of any theorems.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: Appendix C and section 4

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: Appendix C and section 4. Our code is available at https://github.com/ changwoolee/BLAST .

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/ public/guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be possible, so 'No' is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ( https: //nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: Appendix C and section 4.

Guidelines:

The answer NA means that the paper does not include experiments.

The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.

The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [Yes]

Justification: We reported the standard deviation in Table 4.

Guidelines:

The answer NA means that the paper does not include experiments.

The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: Section 4 and appendix C.

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: Our paper is written upon widely-used publicly available datasets and models. We discuss potential harmful impact in Appendix E.

Guidelines:

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.

If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).

10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [Yes]

Guidelines:

The answer NA means that there is no societal impact of the work performed.

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.

The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA]

Justification: Instead of providing a decomposed Llama-7B model, we provide the code file to reproduce the result if one can access the original safeguarded model.

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.

We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [Yes]

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.

If this information is not available online, the authors are encouraged to reach out to the asset's creators.

13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [Yes]

Justification: Documentation is available in the project directory at https://github.com/ changwoolee/BLAST .

Guidelines:

The answer NA means that the paper does not release new assets.

Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.

14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: We did not conduct experiments with human subjects nor croudsourcing.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.

According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: We did not conduct experiments with human subjects nor croudsourcing.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.

For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes to compress linear layers by using a block low-rank structure with shared basis -- also known as the BLR^2 matrix structure. The basis U, V, and diagonal weights s of the low-rank block are computed through a gradient-based optimization that minimizes the Frobenius norm between the dense and low-rank matrix. They also use preconditioning to accelerate the convergence.\n\nSTRENGTHS:\nTheir experiments of ViT-s on ImageNet-1k show an improvement in validation accuracy compared to existing methods such as Gaudi-GBLR.\n\nWEAKNESSES:\nWhat is proposed as the BLAST matrix in this paper is an existing matrix structure known as BLR^2 [https://hal.science/hal-03070416]. The original BLR^2 structure uses LQ decomposition to compress the low-rank blocks, but the name of the structure is independent of the method used to compress the low-rank blocks. Therefore, the proposed method which uses a gradient based iterative method to compress the low-tank blocks is still a BLR^2 structure. The BLR^2 paper should be cited, and all mention of BLAST should be replaced with BLR^2. \n\nFor CIFAR-10 and CIFAR-100, Gaudi-GBLR seems to perform better than the proposed method. The authors mention that Gaudi-GBLR's \"capability of learning the adaptive resource/budget allocation for each weight matrix\" is the cause, but it is unclear why this is not the case for ImageNet-1k.\n\nQUESTIONS:\nWhy does the paper repeatedly mention matrix-vector multiplications? The input to DNNs are not vectors.\n\nWhy do the authors mention that \"A block low-rank (BLR) [12], also known as Monarch [13] matrix\"? The Monarch matrix is a very different structure from BLR. \n\nWhy are Gaudi-GBLR, BSP+LR, and BLR excluded from the compression benchmark in Table 2? Just because they haven't been studied as data-free compression techniques doesn't mean they are not suitable for this task.\n\nLIMITATIONS:\nThe limitations are stated clearly in a separate section.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-12"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors propose a learnable compressed representation (BLAST) for weight matrices used in deep learning which enables lower complexity matrix multiplications which approximate the full, uncompressed operation.  A BLAST matrix decomposes the original matrix into a grid of blocks of diagonal matrices with shared low-rank factors along each (block) row and column, and these parameters can be learned directly from a random initialization.  Converting a dense matrix to a BLAST matrix by minimizing the Frobenius norm error between original and compressed matrices can be done through gradient descent factorization, and preconditioning can accelerate convergence.  The proposed technique is evaluated in pre-training, fine-tuning, and data-free compression scenarios, using a variety of networks and tasks (vision transformers and LLMs, image classification, image generation through diffusion, and zero-shot language modeling).\n\nSTRENGTHS:\n**Originality**: The proposed approach seems to be entirely novel, building on existing low rank and block sparse techniques.\n\n**Quality**: In general, the major claims are backed up with the necessary experiments - the impact of preconditioning on convergence speed is demonstrated, and the comparisons against the chosen baseline suggest that the BLAST format is superior in many cases, and at least comparable in most.  The breadth of evaluations is welcomed - different types of models and tasks can behave differently to different techniques, but the applicability of BLAST across this variety is demonstrated appropriately.\n\n**Clarity**: The writing is clear, and the organization is fantastic.  A reader can quickly understand what sets BLAST matrices apart from other techniques, if not the importance of its constituent components (see weaknesses below).\n\n**Significance**: Simplifying deep learning in practice, either by reducing memory or compute costs is an important area, and this submission seemingly approaches both angles.  The relative simplicity of the format and the immediate benefits (shown in Table 4) may make this an attractive technique for practitioners to adopt.\n\nWEAKNESSES:\n**Originality**: While the authors included a sparse-weight baseline (LLM-Pruner), [SparseGPT](https://arxiv.org/abs/2301.00774) deserves mention (and potentially inclusion as a baseline method to compare against).\n\n**Quality**\n\nThe authors claim in line 310 that BLAST matrices allow \"more efficient execution in hardware for the same FLOPs (in Figure 5, Figure 6, and Table 1),\" but these figures and table don't tell the reader anything about hardware efficiency.  While the authors have presented an algorithm for matrix-vector products, I'm not convinced that matrix-matrix multiplication is as efficient as optimized dense routines tensor execution units in any recent hardware.  (The runtime speedups in Table 4 may simply be due to the memory and bandwidth savings, not an computational gains.)\n\nThe authors stress that U and V are shared along rows and columns, but it's unclear why this is so important.  What if each block has its own U and V -- other than increasing the number of parameters, would the factorization process, quality of the results, multiplication algorithms, etc. change?\n\nIn line 245, the authors suggest that certain techniques \"have not been studied as data-free compression techniques\" and are therefore \"excluded from the comparison\" for this task.  I'm not sure if this is fair or not: were these techniques simply not designed for this task, or are they harder to adapt to this task, or are they entirely incompatible?  \n\n**Clarity**: there are some configuration details missing:\n\n- The rank *r* used for the experimental results.  (I see this detail is in the appendix, but I think it's useful to give at least a range of the values used in practice, as was done with *b*, in the main content.)\n\n- The batch size and input sequence length used in the LLM runtime analysis.\n\n\nFigure 4 is lacking vertical axis labels.\n\nI'm not sure of the difference between, in line 100, \"learning\" and \"finding\" the structure of a weight matrix.\n\n\n**Significance**: the quality of the results lets the submission down, in a way.  Compression rates of 10%-20% are fairly limited, and I'd be curious to know what happens, even if it's catastrophic, at higher compression rates -- even 50% would be informative.  Further, the quality of the BLAST diffusion model's output, while better than SVD's, still fall short of the baseline.  Fine detail is lost (in e.g. the water and rocks of the fourth column, the feathers in the fifth column, and the jersey in the sixth), and larger distortions appear (the hippo's snout no longer looks accurate, the bird's eye has disappeared, and the hot air balloon's shape is extremely lopsided).  Again, these results are better than the other Low-Rank technique, but practitioners may be hesitant to use the technique for this task without significant gains.\n\nQUESTIONS:\n1. Is matrix-matrix multiplication built by performing multiple matrix-vector products (Algorithm 1), or is there something more clever that can be done?\n\n2. What is the difference, in line 100, between \"learning\" and \"finding\" the structure of a weight matrix?\n\n3. What is the benefit (other than parameter reduction) in sharing the U and V factors along rows and columns?  Can it be quantified?\n\n4. What rank *r* is used for the experimental results?\n\n5. Regarding skipping some baselines for comparisons, were these techniques simply not designed for this task, or are they harder to adapt to this task, or are they entirely incompatible?  \n\n6. What batch size and input sequence length was used for the results in Table 4?\n\nLIMITATIONS:\nThe authors' discussion is excellent, only missing one potential further limitation: this technique seems like it'd need extra work to apply to higher-dimensional tensors.  I could imagine applying it on matrix-slices of a tensor, but this may not work well.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2024-07-12"}

comments: SUMMARY:
This paper attempts to find efficient structures in weight matrices of deep learning models. The basic idea is to learn a group of block-wise low-rank matrices via gradient descent. The proposed method replaces original dense weight matrices and hence needs retraining.

STRENGTHS:
* The paper introduces an original approach on replacing weight matrices of DNNs to be block-wise low-rank through training.
* The evaluation includes multiple models and different tasks, showing good generalizability of this work.

WEAKNESSES:
* The significance of the proposed method remains unclear. Compared with prior methods such as Gaudi-GBLR [14], the accuracy results of this work do not show consistent superior performance nor with a convincing explanation.
* The method does not seem to improve efficiency much, showing limited significance.

QUESTIONS:
* How different is this work compared with block sparse + low-rank [23] and Gaudi-GBLR [24]? Why is adaptive and learnable a new contribution when these ideas have already been proposed? The paper [23] is not introduced before use in experimental results.
* In Table 4, when L is 100, the execution time of 20% compression ratio increases compared with no compression, while other two columns show slight reduction of execution time. What is the reason? 
* Please provide more details, even if it is obvious, that the learned BLAST matrix structures do not need any library function customization. What is specifically used as the backend compute kernel?

LIMITATIONS:
Yes.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2024-07-12