FRUGAL: Memory-Efficient Optimization by Reducing State Overhead for Scalable Training

## Abstract

Abstract With the increase in the number of parameters in large language models, the process of pre-training and fine-tuning increasingly demands larger volumes of GPU memory.
A significant portion of this memory is typically consumed by the optimizer state.
To overcome this challenge, recent approaches such as low-rank adaptation (LoRA (Hu et al., 2021 ) ), low-rank gradient projection (GaLore (Zhao et al., 2024a ) ), and blockwise optimization (BAdam (Luo et al., 2024 ) ) have been proposed.
However, in all these algorithms, the effective rank of the weight updates remains low-rank , which can lead to a substantial loss of information from the gradient.
This loss can be critically important, especially during the pre-training stage.
In this paper, we introduce FRUGAL ( F ull- R ank U pdates with G r A dient sp L itting), a new memory-efficient optimization framework. FRUGAL leverages gradient splitting to perform low-dimensional updates using advanced
algorithms (such as Adam), while updates along the remaining directions are executed via state-free methods like SGD or signSGD (Bernstein et al., 2018 ) .
Our framework can be integrated with various low-rank update selection techniques, including GaLore and BAdam.
We provide theoretical convergence guarantees for our framework when using SGDM for low-dimensional updates and SGD for state-free updates.
Additionally, our method consistently outperforms concurrent approaches across various fixed memory budgets, achieving state-of-the-art results in pre-training and fine-tuning tasks while balancing memory efficiency and performance metrics.

## 1 Introduction

In recent years, Large Language Models (LLMs) such as GPT (OpenAI, ) and LLaMA-3 Dubey et al. () have demonstrated remarkable performance across various disciplines (Brown, ; Yang et al., ; Romera-Paredes et al., ).
However, a critical factor in achieving these results is the size of these models (Hoffmann et al., ).
A larger number of parameters not only increases computational cost but also significantly raises memory requirements.
For instance, training an 8 billion parameter LLaMA model in a 16-bit format necessitates each parameter to occupy 2 bytes, resulting in 16GB for storing the parameters and an additional 16GB for gradients.
Utilizing the Adam optimizer (Kingma, ), which is standard for pre-training and fine-tuning LLMs, adds a further 32GB of memory to store the $m$ and $v$ statistics, resulting in 64GB total amount of memory.
Furthermore, to achieve higher-quality results, training in pure 16-bit format is often insufficient (Zamirai et al., ).
This necessitates storing master weights and optimizer statistics in 32-bit format, leading to total memory demands that exceed the capacity of cutting-edge graphics cards, such as the A100-80GB.

Numerous research projects have been aimed at reducing these significant costs.
These approaches include engineering solutions like gradient checkpointing Chen et al. () and memory offloading (Rajbhandari et al., ), which do not change the training trajectory.
There are also methods that adjust the training algorithm by decreasing the number of trainable parameters (Frankle & Carbin, ; Wang et al., ; Sreenivasan et al., ; Horváth et al., ) or their bit precision (Wortsman et al., ), as well as optimizer statistics (Dettmers et al., ; Shazeer & Stern, ; Zhang et al., ).
In this work, we concentrate on the latter category.

Parameter-Efficient Fine-Tuning (PEFT) methods, such as LoRA (Hu et al., ), Dora (Liu et al., ), and BitFit (Zaken et al., ) reduce memory costs by training a relatively small number of parameters compared to the size of the original model, while the remaining modules are frozen.
This approach has proven effective for the task of efficient fine-tuning of pre-trained language models.
However, PEFT methods have a fundamental limitation: parameter updates always lie in a low-dimensional subspace, which prevents the use of these methods for pre-training (Lialin et al., ) and may constrain their capabilities in fine-tuning (Zhang et al., ).

Recent works, such as GaLore (Zhao et al., ), ReLoRA (Lialin et al., ), and BAdam (Luo et al., ), offer a solution to this problem.
These methods enable higher-dimensional full-parameter learning by periodically changing the optimizable low-rank subspace, which we will call the state-full subspace.
However, even though these methods result in overall parameter changes that are high-dimensional, the updates in each step remain low-dimensional.
The dimensionality of the state-free subspace significantly exceeds that of the state-full subspace.
The remaining information contained in the gradient is not utilized for parameter updates.
Nevertheless, this information can still be leveraged to train the model.

Figure: Figure 1: FRUGAL reduces memory usage by splitting gradient updates into low-dimensional updates with advanced optimizers (e.g., AdamW) and using state-free methods (e.g., SignSGD and SGD) for the rest.
Refer to caption: extracted/5992506/frugal.png

We present the FRUGAL framework, designed to bridge this gap.
Our approach stems from a crucial observation: although memory constraints prevent the use of advanced optimizers like Adam (Kingma, ) in the state-free subspace, one still can update this subspace using state-free optimization algorithms like Stochastic Gradient Descent (SGD) or signSGD (Bernstein et al., ).
This solution allows for high-dimensional updates, which provides additional opportunities to explore the parameter space and improves convergence.

Contributions. We summarize the main contributions of our work as follows:

- •
We present a new memory-efficient optimization framework that combines the use of advanced optimization algorithms for the state-full subspace with state-free algorithms for the complementary subspace.
The framework supports various types of state-full optimizers, state-free optimizers, and different methods for projecting the gradient onto the state-full subspace.
- •
We provide theoretical convergence guarantees for our framework. In the proof, we consider the case where SGDM acts as the state-full optimizer and SGD as the state-free optimizer, and we show that FRUGAL matches the best-known convergence rate in many scenarios.
- •
To verify the practical applicability of FRUGAL, we conduct extensive experiments in popular real-world scenarios.(^1^11The code is available at [https://github.com/fzmushko/FRUGAL](https://github.com/fzmushko/FRUGAL).)
In these experiments, we pre-train LLaMA-like models (up to 1B parameters) on the Colossal Clean Crawled Corpus (C4) dataset (Raffel et al., ) and fine-tune RoBERTa (Liu, ) on the GLUE benchmark (Wang, ).
The results show that our method significantly outperforms previous memory-efficient algorithms while using the same memory budget.
- •
We demonstrate that only the Logits layer in transformer-like models requires advanced optimizers like Adam, while other modules (including Embeddings and RMSNorms) can use simpler methods like signSGD without significant performance loss.
This opens new possibilities for memory-efficient training and provides crucial insights into the learning dynamics of Transformers.

## 2 Related work

Memory-efficient full-parameter learning.
Recent research has focused on reducing the memory footprint of LLMs by decreasing the size of optimizer states while maintaining their performance.
Low-rank adaptation methods, such as LoRA (Hu et al., ), inject trainable rank decomposition matrices into each layer of the model, reducing memory requirements by optimizing only a few learnable adapters.
ReLora (Lialin et al., ) builds upon this by merging low-rank adaptations into the main model weights during training, potentially increasing the total rank of the update.
BAdam (Luo et al., ) leverages Block Coordinate Descent for full-parameter training by switching active blocks during fine-tuning.
MicroAdam (Modoranu et al., ) compresses gradient information before feeding it into the optimizer state, significantly reducing memory footprint while enabling full parameter learning through error feedback mechanisms.
GaLore (Zhao et al., ) maintains full parameter learning by projecting gradients onto a low-rank subspace using truncated SVD decomposition, storing optimizer states in this reduced space.
Notably, GaLore achieves good results in pre-training, with performance close to that of Adam.
However, while these methods effectively reduce memory overhead, they all perform low-rank updates at each iteration.
In contrast, our approach utilizes all available gradient information to perform full-dimensional updates at each optimizer step, offering a novel perspective on memory-efficient optimization for LLMs.

Other memory-efficient optimization.
Several other methods have been proposed to reduce the memory footprint of optimizers.
AdaFactor (Shazeer & Stern, ) attempts to mimic Adam’s behavior while reducing memory usage through factorization of the variance matrix $v$.
Adam-mini (Zhang et al., ) further reduces memory by storing only one value $v$ per block.
Dettmers et al. () and Li et al. () decrease memory footprint by quantizing optimizer states to the lower-precision representations.
Lv et al. () proposed to reduce weight gradient memory by fusing the backward operation with the optimizer update.
Notably, these approaches are orthogonal to our method FRUGAL and can be combined with it for further memory efficiency.

Block Coordinate Descent.
Block Coordinate Descent (BCD) is a well-established optimization method with a rich history in mathematical optimization (Ortega & Rheinboldt, ; Tseng, ; Richtárik & Takáč, ; ; Richtárik & Takác, ; Takáč et al., ; Richtárik & Takáč, ).
In recent years, a specific instance of BCD, known as layer-wise learning, has been applied to deep learning. Notable examples include (Luo et al., ; Pan et al., ), which leverage this approach for LLM fine-tuning.
To the best of our knowledge, our work presents the first theoretical analysis of an extended BCD framework (Section 4) where the remaining coordinates are also updated using a different algorithm.
This novel approach extends traditional BCD techniques, opening new avenues for full model optimization in deep learning.

Sign-based methods for training language models.
Since its introduction, Adam has become the de facto primary optimization algorithm, demonstrating superior practical results compared to SGD-based algorithms across various deep learning tasks. This difference is particularly noticeable when training Transformers on language tasks.
While Zhang et al. () hypothesized that Adam outperforms SGD in this setup due to the heavy-tailed distribution of sampling-induced errors, Kunstner et al. () demonstrated that this superiority persists even in full-batch training.
They proposed a new hypothesis suggesting that Adam’s key success factor is related to its similarity to signSGD (Balles & Hennig, ; Balles et al., ), and both Kunstner et al. () and Zhao et al. () showed that signed descent with momentum reduces the performance gap with Adam.
In contrast, to the best of our knowledge, we are the first to train the majority of language model’s parameters using signSGD without momentum, achieving minimal loss in quality.
This approach further demonstrates the effectiveness of sign-based methods for LLM training, paving the way for more efficient and scalable optimization strategies in deep learning.

**Table 1: Comparison of different projection and optimization strategies on pre-training LLaMA-130M on C4 with Adam as the state-full algorithm. State-free subspace is updated for full-rank methods but frozen for low-rank methods. Low-rank SVD outperforms Low-rank Random at the beginning of training but falls behind later due to insufficient exploration of the parameter space.**
| Method | Validation perplexity after iterations $\downarrow$ |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| 4k | 20k | 40k | 100k | 200k |  |
| Low-rank SVD | 39.75 | 26.35 | 24.38 | 22.30 | 21.11 |
| Low-rank Random | 42.31 | 25.99 | 23.55 | 21.33 | 20.01 |
| Full-rank Random | 37.26 | 23.46 | 21.53 | 19.66 | 18.64 |
| Full-rank SVD | 33.96 | 22.54 | 21.01 | 19.30 | 18.35 |
| Full-rank RandK | 36.38 | 23.02 | 21.25 | 19.70 | 18.63 |
| Full-rank Block | 37.20 | 23.34 | 21.42 | 19.59 | 18.60 |
| Adam | 33.95 | 21.90 | 20.56 | 18.97 | 18.13 |

## 3 FRUGAL : Full-Rank Updates with GrAdient spLitting

In this section, we first introduce two main building blocks of our method and then introduce our general framework.

### 3.1 The importance of exploring the entire space during the training process

In recent work, Zhao et al. () proposed GaLore, an optimization method based on projecting the gradient matrix ${\bm{G}}$ of each layer onto a low-dimensional subspace.
To obtain the projection matrix ${\bm{P}}$, they use SVD decomposition of ${\bm{G}}_{t}$, which is recomputed with frequency $T$.
The vectors or rows of ${\bm{G}}$ are projected onto the first $r$ left or right singular vectors, respectively.
This approach has theoretical foundations: the first $r$ singular vectors correspond to the first $r$ singular values and, therefore, should better utilize information from the spectrum of ${\bm{G}}$.

The authors pointed out that calculating the SVD decomposition results in extra computational overhead, which can be as much as a 10% increase as the hidden size of the model grows.
To minimize this cost and examine the significance of using SVD decomposition, one may wonder about the possibility of employing a random semi-orthogonal projection matrix ${\bm{R}}$ instead of projecting onto the first $r$ singular columns with ${\bm{P}}$.
Surprisingly, we found that although SVD decomposition delivers an initial boost, subsequent training with random projection yields significant improvements.
As an illustration, we took the pre-training(^2^22See Section 5.1 for a detailed description and discussion on the experimental setup.)
of a 130M model with LLaMA-like architecture on the C4 dataset (Raffel et al., ).
The results are presented in Table 1, where training with ${\bm{P}}$ corresponds to the row labeled “Low-rank SVD”, and training with ${\bm{R}}$ corresponds to the row labeled “Low-rank Random”.
The ranks of both projections ${\bm{P}}$ and ${\bm{R}}$ equal $192$.

To investigate this phenomenon, we pre-trained the LLaMA-60M model and collected gradients ${\bm{G}}_{t}$ from different iterations $t$ for examination.
Following the setup from GaLore (Zhao et al., ), we computed SVD decompositions and extracted projections ${\bm{P}}_{t}$ with a rank of 128.
We evaluated the similarity of the projection matrices by calculating the principal angles between different projections ${\bm{P}}_{t}$ at different steps.
Similarly to the observations in Q-Galore (Zhang et al., ), we found that these projections show minimal change during the training period; see Figure 2.

Here, we take the projection matrix corresponding to the $5$-th layer and plot histograms of the cosine of the principal angles between pairs ${\bm{P}}_{t}$ and ${\bm{P}}_{t^{\prime}}$ from different iterations.
For comparison, we also include the random projections on the right.
As can be seen, the distributions of cosines differ significantly for the ${\bm{P}}_{t}$ and for the random projections.
While ${\bm{R}}_{t}$ feature no angles with cosines higher than $0.9,$ the top $57$ cosines for ${\bm{P}}_{t}$ surpass $0.9$, even for gradients $1000$ steps apart.

This leads to the conclusion that although SVD decomposition generally better captures the information contained in the ${\bm{G}}_{t}$, the original GaLore algorithm updates weights only in a small subspace.
We hypothesize that training with random projections yields superior results due to the more extensive investigation of the optimizable space during the training process.
This finding indicates that to achieve better convergence, it is important to seek out optimization algorithms that explore the entire space during the training process.

### 3.2 Advantage of the Full-Rank Updates

The insight from the Section 3.1 suggests that the training of language models performs significantly better when the entire parameter space is utilized during the training process. Given the importance of updating parameters in all directions, this poses the question: Is it optimal to use low-rank updates, as employed by methods such as GaLore (Zhao et al., ), ReLoRA (Lialin et al., ), and BAdam (Luo et al., )? Using low-rank updates means the effective rank of the update is significantly smaller than the full dimensionality of the parameter space, inevitably leading to a loss of valuable information contained in the gradient.

However, the method to leverage the full-rank gradient for updating parameters is not readily obvious.
Using algorithms like Adam (Kingma, ) is not an option due to the memory overhead they introduce, which is precisely what we aim to avoid.
An alternative approach is to use state-free optimizers such as SGD or signSGD (Bernstein et al., ).
Unfortunately, SGD have been shown to be ineffective for training transformer models, as shown in Zhang et al. (); Pan & Li ().

Figure: Figure 2: Histograms of principal angle cosines. The first three are taken between ${\bm{P}}_{t}$ and ${\bm{P}}_{t^{\prime}}$ from different iterations $t$ and $t^{\prime}$. ${\bm{P}}$ is obtained from the truncated SVD decomposition of the gradient ${\bm{G}}$ of the Key projection from the 5th layer. The last histogram is taken between two random semi-orthogonal projections ${\bm{R}}$ and ${\bm{R}}^{\prime}$ for comparison.
Refer to caption: x1.png

Nevertheless, a recent study Zhao et al. () suggests a promising methodology: while SGDM doesn’t generally work well with transformers, using SGDM for the majority of parameters and Adam for a selected subset can lead to effective training.
This raises the question: could a hybrid approach using SGD or signSGD instead of SGDM be viable?
If the key subset of parameters is handled by advanced algorithms, can the other parameters be trained effectively with state-free optimizers?

To address this question, we conducted an experiment on LLaMA-130m, where we utilized the Adam (Kingma, ) for state-full parameters and signSGD (Bernstein et al., ) for state-free parameters.
A detailed description of the experimental setup can be found at Section A.1.
The result is highlighted as the entry “Full-rank Random” in Table 1.
Full-rank updates significantly enhance performance, approaching the efficiency of the memory-intensive Adam optimizer, which serves as a upper bound in terms of performance.
These findings underscore the potential of state-free algorithms for updating a substantial portion of the parameter space, paving the way for efficient, scalable optimization methods that deliver high performance without the significant memory costs traditionally associated with state-of-the-art optimizers.

### 3.3 FRUGAL as Optimization Framework

The setup outlined at the conclusion of the Section 3.2 results in a general framework for memory-efficient optimization.
Briefly, it operates as follows: the entire space is partitioned into state-full and state-free subspaces.
The state-full subspace is updated using advanced algorithms, while the state-free subspace is updated using a state-free method.
After a certain number of steps, the state-full subspace is changed to better explore the optimization space.
However, determining the optimal state-free optimizer and the projection method onto the state-full subspace is not readily apparent.
In this section, we strive to find the optimal configuration.

State-free optimizer.
We conducted a preliminary experiment updating all parameters using state-free algorithms to choose between SGD and signSGD (Bernstein et al., ).
Table 8 presents these results.
After testing various learning rates, we found that signSGD consistently outperforms SGD, leading us to favor signSGD.
We attribute this performance to the similarities between signSGD and Adam (Kingma, ), as noted in Balles & Hennig (); Balles et al. (); Kunstner et al. ().
Additionally, signSGD produces updates of similar magnitude to those generated by Adam, which simplifies the calibration of the learning rate for state-free parameters.

Projection type. When selecting a projection method, it is crucial to strike a balance between quality and memory efficiency.
For instance, the approach using the projection matrix from SVD decomposition, as in GaLore (Zhao et al., ), better preserves the information embedded in the gradient but requires additional memory for storing projection matrices and computational resources for performing the SVD.
To reduce computational demands, one could employ random coordinate projection denoted as RandK, but this requires additional memory or recomputation(^3^33See Appendix B for discussion on the memory requirements for different projection methods.).
A more structured alternative is to select not random matrix elements but entire random columns or rows.
The most aggressive approach follows the method from BAdam, wherein an entire block is chosen as the state-full subspace.

The performance results obtained with all these variants are presented in Table 1.
Full-rank SVD outperforms both Full-rank RandK and Full-rank Block methods, demonstrating comparable performance.
The superior performance of SVD projections can be explained by their ability to extract the principal information from the gradient.
Nonetheless, a downside is the increased compute and memory demand from SVD.
Therefore, we opt for the blockwise selection, as it is the most memory-efficient — requiring only the storage of active block indices.

A formal description of the final algorithm is presented in Algorithm 1.
It’s worth noting that this framework allows for variation not only in the State-Full algorithm but also in the choice of projection and State-Free optimizer.
In our experiments in Section 5, we use a specific variant with Adam as the State-Full optimizer, signSGD as the State-Free optimizer, and blockwise
projection.

For Line 7, state projection, in Algorithm 1, we note that if the projection does not change, i.e., $P_{k,i}=P_{k-1,i}$, then $P_{k,i}(P^{-1}_{k-1,i}(s))=s$.
Thus, we only need to project states when the projection changes from one round to another.
However, our preliminary experiments with RandK selection showed that resetting states performs comparably to projection.
Therefore, we could replace this projection with state resetting when the projection changes, which also aligns with blockwise subspace selection.
However, either resetting or projecting states is important since we want projected gradients and optimizer states to reside in the same space.
For instance, GaLore ignores this step, which leads to degraded performance when projections are updated frequently; see Appendix C for details.

Figure: Algorithm 2 FRUGAL (SGDM, SGD)

## 4 Theoretical Results

For the theoretical analysis, we consider the case where the State-Free optimizer is SGD and the State-Full optimizer is SGD with momentum (SGDM). For the projection, we use coordinate-wise projection. This special case of FRUGAL is provided in Algorithm 2. We minimize the following objective

$$ $\displaystyle\textstyle\min_{x\in\mathbb{R}^{d}}\big{\{}f(x):=\mathbb{E}_{ \zeta}[f_{\zeta}(x)]\big{\}},$ (1) $$

where we access $f$ via a stochastic oracle that takes $x$ as input and returns $(f_{\zeta}(x),\nabla f_{\zeta}(x))$.

### 4.1 Notation and Preliminaries

We use $\|\cdot\|$ for the vector $\ell_{2}$-norm, and $\langle\cdot,\cdot\rangle$ stands for the dot product. Let $g^{k}$ denote the full gradient of $f$ at $x^{k}$, i.e., $g^{k}\coloneqq\nabla f(x^{k})$, and $f^{*}\coloneqq\min_{x\in\operatorname*{\mathbb{R}^{d}}}f(x)$. We use subscript $j$ to denote the $j$-th coordinate.

###### Assumption 1 .

We make the following assumptions, which are standard in non-convex stochastic optimization; see (Liu et al., ).

- 1.
Smoothness: The objective $f(x)$ in equation 1 is $L$-smooth.
- 2.
Unbiasedness: At each iteration $k$, $\tilde{g}^{k}$ satisfies $\mathbb{E}_{\zeta^{k}}[\tilde{g}^{k}]=g^{k}$.
- 3.
Independent samples: The random samples $\{\zeta_{k}\}_{k=1}^{\infty}$ are independent.
- 4.
Bounded variance: The variance of $\tilde{g}_{j}^{k}$ with respect to $\zeta^{k}$ satisfies $\mathrm{Var}_{\zeta^{k}}(\tilde{g}_{j}^{k})=\mathbb{E}_{\zeta^{k}}[\|\tilde{g}
_{j}^{k}-g_{j}^{k}\|^{2}]\leq\sigma_{j}^{2}$ for some $\sigma_{j}^{2}>0$. We denote $\sigma^{2}=\sum_{j=1}^{d}\sigma^{2}_{j}.$

Finally, we define the probability that index $j\in J_{k}$ is selected, conditioned on the prior iteration $k-1$, as $p^{k}_{j}:=\Pr_{k-1}[j\in J_{k}].$ Other useful quantities are $p^{k}_{\max}:=\max_{j\in[d]}\{p^{k}_{j}\}$ and $p^{k}_{\min}:=\min_{j\in[d]}\{p^{k}_{j}\}$.

###### Assumption 1 .

### 4.2 Convergence of Algorithm 2

Below, we present the main convergence theorem.

###### Theorem 1 .

Let Assumption 1 hold and $\alpha^{k}=\alpha\leq\frac{1-\beta}{L(4-\beta+\beta^{2})}$. Then, the iterates of Algorithm 2 satisfy

$$ $\displaystyle\frac{1}{k}\sum_{i=1}^{k}\mathbb{E}[\|g^{i}\|^{2}]$ $\displaystyle=\mathcal{O}\left(\frac{f(x^{1})-f^{*}}{k\alpha}+L\alpha\sigma^{2 }\left(1+\frac{\hat{p}^{k}_{\max}(1-\bar{p}^{k}_{\min})\beta}{(1-\beta)}\right )\right),$ (2) $$

where $\bar{p}^{k}_{\min}=\frac{1}{k}\sum_{i=1}^{k}\bar{p}^{i}_{\min}$ and $\hat{p}^{k}_{\max}=\max_{i\in[k]}\{p^{i}_{\max}\}$.

The proof is deferred to Appendix E. Let us analyze the obtained result. Firstly, if $J_{k}=[d]$ or $J_{k}=\emptyset$, Algorithm 2 becomes SGDM and SGD, respectively. In this case, we have $\bar{p}^{k}_{\min}=1$ for SGDM and $\hat{p}^{k}_{\max}=0$ for SGD. Therefore, the resulting rate is $\mathcal{O}\left(\nicefrac{{1}}{{k\alpha}}+L\alpha\sigma^{2}\right)$, which recovers the best-known rate for both SGD and SGDM under these assumptions Liu et al. (). Furthermore, if at each step each coordinate is sampled independently with probability $p$, we have $\bar{p}^{k}_{\min}=\hat{p}^{k}_{\max}=p$. Therefore, we recover the same rate if $p=\mathcal{O}\left(1-\beta\right)$ or $p=\mathcal{O}\left(\beta\right)$. Finally, in the worst case (e.g., $J_{k}$ is deterministic and $0<|J_{k}|<d$), we have $\bar{p}^{k}_{\min}=0$ and $\hat{p}^{k}_{\max}=1$. Thus, the rate becomes $\mathcal{O}\left(\nicefrac{{1}}{{k\alpha}}+\nicefrac{{L\alpha\sigma^{2}}}{{1-
\beta}}\right)$, which is worse by a factor of $\nicefrac{{1}}{{1-\beta}}$. However, this is expected since the bias from momentum is not outweighed by the variance reduction effect, as only the coordinates with momentum enjoy reduced variance; see Lemmas 1 and 2 in the appendix for details.

###### Theorem 1 .

## 5 Experiments

This section presents the main experimental results of the paper.
To evaluate the performance of FRUGAL, we conducted experiments both on the pre-training and fine-tuning of language models.

### 5.1 Pre-training experiments

Setup.
The core setup for pre-training is taken from the Zhao et al. ().
We utilize LLaMA-based (Touvron et al., ) model architectures with up to 1B parameters and train them on the Colossal Clean Crawled Corpus (C4) dataset (Raffel et al., ).
The C4 dataset is intended for pre-training, making this setup a good approximation of real-world applications.
A detailed description of the setup can be found in Section A.1.
However, we made several modifications that we would like to discuss in detail below.

- •
Training Duration.
The training approach in Zhao et al. () aligns with the empirical rule from scaling laws (Hoffmann et al., ), which suggests using approximately 20 times the model size in tokens for training.
However, this number of tokens is far from achieving convergence.
In practice, models are typically trained for significantly longer periods (Touvron et al., ; Zhang et al., ).
One reason for this discrepancy is that the original scaling laws do not account for the inference of the model after training.
Adjustments to scaling laws considering this parameter are discussed, for example, in (Sardana & Frankle, ).
For our experiments we chose 200k steps for the 60M and 130M models, 240k for 350M model and 300k for the 1B model.
- •
Learning Rate.
The authors of GaLore suggested using different learning rates for fixed unprojectable parameters (Embeddings, RMSNorms (Zhang & Sennrich, ), Logits) and the remaining projectable parameters (attention and FFN weights modules weights).
However, introducing additional hyperparameters complicates the use of the algorithm.
Since both sets of parameters are state-full and trained using the same optimization algorithm, we always used the same learning rate for them in FRUGAL and BAdam. For GaLore learning rate see Section 5.1.
- •
Mixed Precision instead of the pure bfloat16 training.
Pure 16-bit training has been shown to potentially compromise model convergence and accuracy (Zamirai et al., ).
This degradation stems from storing both the model weights and optimizer statistics in reduced precision formats such as float16 or bfloat16.
However, these formats often lack sufficient precision in representing floating-point numbers.
Consequently, mixed precision training has become a more common approach for training language models (Le Scao et al., ; Almazrouei et al., )).
While training in pure 16-bit format is also possible, stochastic rounding (Gupta et al., ; Zamirai et al., ) is often employed to mitigate the aforementioned issue.
Given that the goal of this research is to identify the optimal optimization algorithm, we deemed it more appropriate to compare optimizers in a transparent and stable setup that does not require auxiliary tricks.
Hence, we primarily used Mixed Precision training for its illustrative value in understanding each method’s potential.
However, for completeness, we also conducted experiments in pure bfloat16 format, detailed in our ablation study Section 5.1.2.

**Table 2: Comparison of validation perplexity and memory estimation for various optimization methods across LLaMA model scales trained on C4. Lower $\downarrow$ is better. In parentheses, we also indicate the additional memory overhead introduced by the optimization algorithm. The values are calculated assuming that each float value occupies 4 bytes (float32). Note that Embeddings, RMSNorms, and Logits are always trained using state-full Adam.**
|  | 60M | 130M | 350M | 1B |
| --- | --- | --- | --- | --- |
| Adam | 22.73 (0.43G) | 18.13 (1.00G) | 14.43 (2.74G) | 12.02 (9.98G) |
| GaLore, $\rho=0.25$ | 25.68 (0.30G) | 21.11 (0.54G) | 16.88 (1.10G) | 13.69 (3.41G) |
| BAdam, $\rho=0.25$ | 24.86 (0.29G) | 20.34 (0.52G) | 16.41 (1.05G) | 13.75 (3.23G) |
| FRUGAL, $\rho=0.25$ | 23.59 (0.29G) | 18.60 (0.52G) | 14.79 (1.05G) | 12.32 (3.23G) |
| FRUGAL, $\rho=0.0$ | 24.06 (0.24G) | 18.90 (0.37G) | 15.03 (0.49G) | 12.63 (0.98G) |
| Training tokens | 20B | 20B | 24B | 30B |
| Number of iterations | 200k | 200k | 240k | 300k |

#### 5.1.1 Comparison to existing memory-efficient algorithms

To begin, we present the results of comparing FRUGAL with existing memory-efficient methods across four sizes of LLaMA-based architectures: 60M, 130M, 350M, and 1B(^4^44See preliminary experimental results with LLaMA 7B in Appendix D).

Baselines. We use the following methods as baselines for our approach:

- •
Full-rank Training.
Training using memory-inefficient Adam.
Weights, gradients, and
statistics are stored and computed for all parameters.
This serves as an upper bound for model performance.
- •
GaLore. Zhao et al. () proposed GaLore, a memory-efficient optimization algorithm that uses a low-rank projection of gradient matrices ${\bm{G}}$.
Every $T$ steps, the current gradient matrix ${\bm{G}}_{t}$ is used to compute the projection matrix ${\bm{P}}$ via SVD decomposition.
The gradient is then projected onto the low-rank space, where the optimization step is performed.
Subsequently, the resulting low-rank update is projected back into the full-rank space and added to the weights ${\bm{W}}$.
- •
BAdam. Luo et al. () proposed a block coordinate descent (BCD)-type optimization method termed BAdam.
The parameters are divided into blocks, which are then updated one by one using Adam.
Similar to GaLore, the optimized block is updated every $T$ steps.
Although this method was initially proposed only for fine-tuning, it is the closest method to our FRUGAL.
Unlike BAdam, in our algorithm, state-free blocks are not frozen but are updated using signSGD.
- •
Other Algorithms. Among other relevant methods, ReLoRA (Lialin et al., ) and MicroAdam (Modoranu et al., ) can also be highlighted.
However, we did not include them for comparison in this paper for the following reasons:
1. ReLoRA was evaluated in (Zhao et al., ), where it significantly underperformed compared to GaLore with the same memory budget.
2. MicroAdam. Its current implementation only supports bfloat16 master weights, whereas our main experiments conducted with mixed precision.

Main results. The results of our experiments are presented in Table 2, which includes both validation perplexity and memory footprint estimations for each method.
We compared all memory-efficient methods under the same memory budget, specifically with a density $\rho=0.25$.
Here, $\rho$ refers to the proportion of state-full parameters (see Section A.1 for a detailed explanation).

We conducted a grid search to determine the optimal learning rate for Adam, which we then applied uniformly to FRUGAL and BAdam (Luo et al., ).
For GaLore (Zhao et al., ), we found that using this same learning rate produced better results than the rate originally suggested in their paper.
This discrepancy might be attributed to our experiments involving a significantly larger number of training steps than those for which GaLore’s original learning rate was optimized.

Table 2 demonstrates that FRUGAL significantly outperforms the memory-efficient baselines across all model sizes with the same memory budget, coming close to the performance of Adam.

**Table 3: Perplexity of LLaMA-130M models pre-trained on C4 for 100k iterations (10B tokens). The leftmost column indicates the modules moved to the state-free set and trained using signSGD. The results show that Logits, unlike Embeddings and RMSNorms, are exceptionally responsive to the choice of optimization algorithm from Adam to signSGD.**
| State-free modules | Perplexity $\downarrow$ |
| --- | --- |
| Linear (corresponds to the FRUGAL with $\rho=0.0$) | 20.02 |
| Linear, RMSNorms | 20.07 |
| Linear, Embeddings | 20.48 |
| Linear, Embeddings, RMSNorms | 20.55 |
| Linear, Logits | 34.66 |

Zero-density training.
Table 2 also reveals a surprising result: FRUGAL with $\rho=0.0$ significantly outperforms both GaLore and BAdam, even when these competing methods use a higher density of $\rho=0.25$.
Essentially, in this case, the parameters are divided into two parts — a state-full part consisting of the Embeddings, RMSNorms, and Logits, and a state-free part consisting of all other parameters.
This division remains fixed throughout the training.
We conducted additional experiments to determine the maximum subset of parameters that can be trained with a state-free optimizer without significant quality degradation.
We systematically moved different combinations of the Embeddings, RMSNorms, and Logits from the state-full to the state-free set and observed the results during the training of LLaMA-130M.
Table 3 reveals that the Logits demonstrates a dramatically higher sensitivity, with changes to its optimizer resulting in severe performance degradation.
This finding aligns with results from (Zhao et al., ), where the authors demonstrated that most parameters can be trained using SGDM, but the Logits require training with Adam.

#### 5.1.2 Ablation study

We also conducted additional experiments to verify the robustness of our framework to various hyperparameters.
Firstly, an ablation study on the state-full subspace update frequency $T$ in Table 10 shows that the performance keeps improving up to $T=200$.
We note that, unlike in Zhao et al. (), the perplexity does not significantly decrease even when reducing the update frequency to $T=10$ ($\sim 0.2$ drop vs. $\sim 4.$ drop for GaLore). A detailed explanation for this result can be found in Appendix C.
Second, when using other schedulers, the performance gap between FRUGAL and baselines remains consistent, as shown in Tables 6 and 6.
Then, the results of training in pure bfloat16 are presented in Table 8, demonstrating consistency with our main experiments in Table 2, i.e., FRUGAL significantly outperforms the baselines across these variations.
We also conducted experiments to show how perplexity changes with varying $\rho$, and the results are presented in Table 11.
Finally, we conducted an experiment to compare different strategies for selecting state-full blocks during training. The results in Table 10 show that there is no significant difference between random and structured block selection.

### 5.2 Fine-tuning experiments

**Table 4: Evaluating FRUGAL for memory-efficient fine-tuning RoBERTa-Base on GLUE benchmark. Results represent the mean and standard deviation across 3 independent runs. Upper $\uparrow$ is better.**
| Method | Modules | Rank | CoLA | STS-B | MRPC | RTE | SST2 | MNLI | QNLI | QQP | Avg |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LoRA | QV | 8 | 63.8$\pm$.6 | 90.9$\pm$.1 | 89.1$\pm$.4 | 79.2$\pm$1.1 | 94.8$\pm$.2 | 87.6$\pm$.2 | 93.1$\pm$.1 | 90.6$\pm$.0 | 86.1 |
| GaLore | All | 8 | 60.0$\pm$.2 | 90.8$\pm$.1 | 89.0$\pm$.7 | 79.7$\pm$.9 | 94.9$\pm$.5 | 87.6$\pm$.1 | 93.3$\pm$.1 | 91.1$\pm$.1 | 85.8 |
| GaLore | QV | 8 | 56.1$\pm$.8 | 90.8$\pm$.2 | 88.1$\pm$.3 | 74.7$\pm$1.9 | 94.3$\pm$.1 | 86.6$\pm$.1 | 92.6$\pm$.1 | 89.4$\pm$.1 | 84.1 |
| FRUGAL | QV | 8 | 64.5$\pm$.7 | 91.1$\pm$.1 | 89.2$\pm$.3 | 82.4$\pm$.9 | 94.8$\pm$.2 | 87.4$\pm$.1 | 92.8$\pm$.1 | 91.4$\pm$.1 | 86.7 |
| FRUGAL | None | 0 | 64.8$\pm$.5 | 91.1$\pm$.1 | 89.1$\pm$.3 | 81.6$\pm$.6 | 94.9$\pm$.2 | 87.3$\pm$.1 | 92.8$\pm$.1 | 91.3$\pm$.1 | 86.6 |

We evaluated the performance of our framework in the context of memory-efficient fine-tuning using the GLUE benchmark (Wang, ), a widely-used collection of tasks for evaluating language models.
Following the approach from Zhao et al. (), we fine-tuned RoBERTa-base (Liu, ) using LoRA (Hu et al., ) and GaLore as baselines for comparison.
We adhered to the setup described in LoRA, where low-rank updates of rank 8 were applied only to the Q and V matrices. For a detailed description of the experimental setup, see Section A.2.

However, this comparison required a minor modification to FRUGAL compared to the pre-training phase.
Instead of selecting active parameters blockwise, we opted for columnwise selection in each matrix.
This adjustment was necessary to ensure a fair comparison within a similar memory budget, as the number of trainable parameters in LoRA with rank 8 is approximately $2.5$ times fewer than the number of trainable parameters in any RoBERTa matrix.
This transition from blockwise to columnwise selection allowed us to maintain comparable memory usage across methods.
For the same reason, we did not include comparisons with BAdam (Luo et al., ) in this setup.

The results are presented in Table 4.
Since the LoRA setup adds trainable adapters only to the Q and V matrices, while the GaLore code uses all modules as projectable parameters, we conducted experiments in both setups.
The results demonstrate that FRUGAL significantly outperforms GaLore and shows comparable results to LoRA.

As in Section 5.1.1, we conducted additional experiments with FRUGAL using $\rho=0.0$.
In this setup, only the classification head is trained using Adam, while the embedding parameters remain frozen, and the remaining parameters are trained using signSGD.
The results demonstrate that this training approach barely compromises performance compared to FRUGAL with rank 8, and still outperforms GaLore.
Similar to our findings in Section 5.1.1, we observe that the classification head parameters are particularly sensitive to the choice of optimizer, which can be seen in Table 13 where the model’s performance significantly deteriorates when using signSGD for classification head optimization.

## 6 Conclusion

In this work, we introduce a new memory-efficient optimization framework, FRUGAL.
Within this framework, the optimization space is divided into two subspaces: the first is updated using a state-full algorithm such as Adam, while the second is updated using a state-free algorithm such as signSGD.
We prove theoretical convergence guarantees for our framework with SGDM serving as the state-full algorithm and SGD as the state-free algorithm.
In experiments involving pre-training and fine-tuning of language models, FRUGAL outperforms other approaches while using the same or smaller memory.

## 7 Acknowledgments

The work was done in the Laboratory of Federated Learning Problems of the ISP RAS (Supported by Grant App. No. 2 to Agreement No. 075-03-2024-214).
The work was partially conducted while Philip Zmushko was a visiting research assistant in Mohamed bin Zayed University of Artificial Intelligence (MBZUAI).

## Appendix A Additional experimental details

This section describes the main setups used in the experiments and presents additional experiments.

To begin, we introduce the hyperparameter density $\rho$. This hyperparameter represents the fraction of the total space in Linear layers that is updated with a stateful optimizer. For GaLore, this parameter is equal to $\rho=r/h$, where $r$ is the projection rank, and $h$ is the hidden size of the model. For RandK projection, this parameter can be expressed as $1-s$, where $s$ means sparsity. For BAdam and FRUGAL with the blockwise update, this parameter denotes the ratio of the number of active blocks $a_{\text{block}}$ to the total number of blocks $p$, i.e., $\rho=a_{\text{block}}/p$. When using FRUGAL with the column-wise update, as in Section 5.2, $\rho$ is equal to the ratio of the number of active columns $a_{\text{column}}$ to their total number $h$, i.e., $\rho=a_{\text{column}}/h$.

### A.1 Pre-training

Setup. We adopt a LLaMA-based architecture with RMSNorm and SwiGLU (Wang, ) activations on the C4 dataset.
Following Zhao et al. (), we trained using a batch size of 512 sequences, sequence length of 256, weight decay of 0, and no gradient clipping.
We used T5 tokenizer, since it also was trained on C4 with dictionary size equal to 32k.
Additionally, the update frequency $T$ is set to 200, and the density $\rho=r/h$ is $0.25$ unless stated otherwise.
We also should point out that similarly to Zhao et al. (), we keep Embeddings, RMSNorms (Zhang & Sennrich, ), and Logits in the state-full subspace throughout the training and don’t reset the optimizer state for them.

We used standard Adam hyperparameters: $\beta_{1}=0.9,\beta_{2}=0.999,\varepsilon=1e-8$. For all the methods except GaLore, we selected the learning rate equal to the optimal learning rate for Adam, which we determined through a grid search among values $[1e-4,3e-4,1e-3,3e-3]$. FRUGAL’s learning rate for the state-free optimizer was set equal to that for the state-full optimizer for simplicity and ease of tuning. For a fair comparison with GaLore (Zhao et al., ), we conducted experiments with two learning rate values: 1) the one specified by the authors in the original paper, and 2) the optimal learning rate for Adam, as used for other methods. We did this because the learning rate in the original paper could have been optimized for a different number of iterations.

To match the learning rate changes in the first steps of our training with Zhao et al. (), we used a cosine learning rate schedule with restarts, with a warmup of 10% of the steps in a cycle length, and decay of the final learning rate down to 10% of the peak learning rate. To verify that our results are not sensitive to the choice of scheduler, we repeated the experiments for LLaMA-130M with other schedulers. Results for constant with warm-up and cosine (one cycle) with warm-up schedulers can be found in Tables 6 and 6.

**Table 5: Perplexity of LLaMA-130M models pre-trained on C4 using constant scheduler with warm-up at various training iterations.**
| Method | 100k | 200k |
| --- | --- | --- |
| Adam | 19.51 | 18.51 |
| GaLore, $\rho=0.25$ | 22.63 | 21.03 |
| BAdam, $\rho=0.25$ | 22.31 | 20.66 |
| FRUGAL, $\rho=0.25$ | 19.97 | 18.85 |
| FRUGAL, $\rho=0.0$ | 20.33 | 19.14 |

**Table 7: Perplexity of LLaMA-130M models pre-trained on C4 using pure bfloat16 format both for model weights and optimizer statistics.**
| Method | 100k iterations |
| --- | --- |
| Adam | 21.88 |
| GaLore, $\rho=0.25$ | 24.19 |
| BAdam, $\rho=0.25$ | 25.03 |
| FRUGAL, $\rho=0.25$ | 23.17 |
| FRUGAL, $\rho=0.0$ | 22.64 |

**Table 9: Perplexity of LLaMA-130M models pre-trained on C4 for 200k iterations using FRUGAL with $\rho=1/3$ and different Block update strategy, taken from Luo et al. ().**
| Method | Perplexity |
| --- | --- |
| Random | 18.50 |
| Ascending | 18.54 |
| Descending | 18.50 |

**Table 11: Perplexity of LLaMA-130M models pre-trained on C4 for 200k iterations (20B tokens) using FRUGAL with different density $\rho$.**
|  | FRUGAL |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| $\rho$ | 1.0 (Adam) | 0.5 | 0.33 | 0.25 | 0.125 | 0.0625 | 0.0 | signSgd |
| Perplexity | 18.13 | 18.40 | 18.50 | 18.63 | 18.71 | 18.80 | 18.90 | 33.22 |

### A.2 Fine-tuning

Setup. The batch size and learning rate values used for FRUGAL in the experiments from Table 4 are presented in Table 12.
In all experiments, we set the learning rate for the state-free optimizer to $1/10$ of the learning rate of the state-full optimizer.
Other hyperparameters, such as scheduler, number of epochs, maximum sequence length, and warmup ratio, were taken from Hu et al. ().

**Table 12: Hyperparameters of fine-tuning RoBERTa-base for FRUGAL.**
|  | MNLI | SST-2 | MRPC | CoLA | QNLI | QQP | RTE | STS-B |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Batch Size | 128 | 128 | 16 | 256 | 256 | 128 | 32 | 16 |
| State-full Learning Rate | 5E-05 | 5E-05 | 2E-04 | 5E-04 | 1E-04 | 5E-05 | 2E-04 | 1E-04 |
| State-free lr multiplier |  |  |  | 0.1 |  |  |  |  |
| Rank/Density |  | $r=8\;\;/\;\;r=0\;(\rho=0)$ |  |  |  |  |  |  |

We also present a comparison between fine-tuning using FRUGAL with $\rho=0.0$ and full fine-tuning using signSGD.
Essentially, the only difference is that in the second case, the classification head is updated with signSGD instead of Adam.
The results in Table 13 show that the classification head is extremely sensitive to the optimizer type, and switching the optimizer significantly drops the accuracy.

**Table 13: Results of fine-tuning RoBERTa-Base on several tasks from GLUE. The left column indicates which modules were trained using the state-full optimizer Adam. The remaining modules, except for the frozen Embedding layer, were trained using the state-free signSGD.**
| Method |  | SST2 | QNLI | QQP |
| --- | --- | --- | --- | --- |
| Classification head (corresponds to the FRUGAL with $\rho=0.0$) |  | 94.9$\pm$.2 | 92.8$\pm$.1 | 91.3$\pm$.1 |
| None (corresponds to the fine-tuning using signSGD) |  | 89.7 | 81.6 | 74.3 |

## Appendix B Memory estimation

In this section, we will examine memory requirements for different projection types using the LLaMA-like architecture as an example and show that RandK, column-wise, and blockwise projections result in approximately the same amount of additional memory for a given density value $\rho$ Appendix A. In contrast, the semi-orthogonal projection matrix (GaLore-like) requires a slightly larger value in this setup.
Recall that we follow the setup from Zhao et al. (), where Embeddings, RMSNorms, and Logits remain in the state-full subspace throughout the training, so the projection does not interact with them, and they give the same memory overhead for all projection methods.

Let the number of parameters in the remaining projectable parameters be $P$.
Then, training using Adam gives an additional overhead of $2P$ float values for storing $m$ and $v$ for each parameter.
Now, let’s consider blockwise and column-wise projections and suppose we want to achieve a density $\rho$.
For blockwise, we take $\text{round}(\rho\cdot L)$ layers, where $L$ is the total number of transformer layers, and for column-wise, we take $\text{round}(\rho\cdot k)$ columns for each matrix of size $n\times k$.
Since the memory required to store block or column indices is negligible compared to other costs, we find that the total size of the optimizer state when using Adam as a state-full optimizer will be $2\rho\cdot P$, with an adjustment for rounding.

In the case of RandK projection, we have the same $2\rho\cdot P$ float values ${\bm{M}}$ and ${\bm{V}}$ in the optimizer state.
However, we must also know the current indices corresponding to these values.
On the other hand, it is widely known that if one needs to save a set of random values, they don’t need to store all these values - it’s sufficient to store only the seed from which they were generated.
Thus, for RandK, the total memory also equals $2\rho\cdot P$.

If we recalculate this considering a specific LLaMA-like architecture, each layer consists of 7 matrices: 4 matrices of size $h\times h$ (Query, Key, Value, Output) and 3 matrices of size $h\times h_{ff}$ (Gate, Down, Up), where $h$ is the hidden size of the model, and $h_{ff}$ is the FFN hidden size. In the LLaMA architecture, it’s typically:

$$ $h_{ff}=4h\cdot\frac{2}{3}=\frac{8}{3}h.$ $$

Then, the amount of memory for RandK projection (and consequently for all others mentioned above) is:

$$ $2\cdot(4\cdot(\rho h^{2})+3\cdot(\rho\cdot h\cdot h_{ff}))=2\cdot(4\cdot\rho h ^{2}+3\cdot(\frac{8}{3}\rho\cdot h^{2}))=24\rho\cdot h^{2}$ $$

for each layer on average ($2$ corresponds to the number of matrices ${\bm{M}}$ and ${\bm{V}}$).

In the case of a GaLore-like semi-orthogonal projection matrix, the situation is as follows. We have projections onto a low-rank subspace of rank $r$, where $r=\text{round}(\rho\cdot h)$. Then, for Query, Key, Value, and Output projections, we need to store ${\bm{P}},{\bm{M}},{\bm{V}}\in\mathbb{R}^{h\times r},$ and for Gate, Down and Up projections either ${\bm{P}}\in\mathbb{R}^{h\times r},{\bm{M}},{\bm{V}}\in\mathbb{R}^{h_{ff}\times
r}$, or ${\bm{P}}\in\mathbb{R}^{h_{ff}\times r},{\bm{M}},{\bm{V}}\in\mathbb{R}^{h\times
r}$. Since the second option requires less memory, it is used by default in (Zhao et al., ) and, therefore, in FRUGAL, too. Then, the total memory requirements are:

$$ $4\cdot(3\cdot rh)+3\cdot(2\cdot r\cdot h+r\cdot h_{ff})=12rh+6rh+3rh_{ff}=(12+ 6+3\cdot\frac{8}{3})rh=26\rho h^{2}.$ $$

To sum up, RandK, column-wise and blockwise projection requires $2\rho P$ additional memory, while semi-orthogonal projection (GaLore-like) requires $\frac{26}{24}\cdot 2\rho P=\frac{13}{12}\cdot 2\rho P$ additional memory.

Let’s recall that in addition to this, SVD requires additional computation, which can take up to 10% as the model size increases (Zhao et al., ).
Therefore, for our method, we settled on blockwise projection.

## Appendix C Optimizer state management

In this section, we would like to propose some modifications to the GaLore algorithm.
These modifications are also used in our framework as SVD projection.

Specifically, we want to consider the projection of the state when changing the active subspace.
In GaLore (Zhao et al., ), when updating the projection, the optimizer states $M$ and $V$ do not change. This results in new projected gradients and old $M$ and $V$ being in different subspaces. This implementation has little effect on the result with large values of update frequency $T$, as the values of $M$ and $V$ from the previous subspace decay exponentially quickly. However, more frequent changes $T$ significantly affect the result. We hypothesize that this is why in Zhao et al. () the model quality degraded so significantly when $T$ was decreased, while as seen in Table 10, FRUGAL experiences much less degradation.

There are two different ways to overcome this obstacle: either project the state back to full-rank space or reset the state before a new round.
However, the first option may be challenging in the case of arbitrary projection.
Specifically, while it’s possible to project momentum back to full-rank space (see Alg. 2 in Hao et al. ()), the same cannot be easily done with variance because its values depend quadratically on the projection matrix.
However, the projection of variance will also be trivial if the set of basis vectors for the projection is fixed, which is true, for example, for coordinate projection with RandK.

Figure: Figure 3: Toy example of solving quadratic minimization problem with GaLore-like SGDM with and without re-projection of optimizer state. Algorithm with re-projection converges much faster.
Refer to caption: x2.png

To demonstrate the effectiveness of this improvement, we provide a toy example.
We consider a quadratic minimization problem of $\|W\|^{2},W\in\mathbb{R}^{10\times 10}$.
For optimization, we use GaLore-like SGDM and GaLore-like SGDM with Momentum state projection.
This projection is similar to Alg. 2 from (Hao et al., ), except we additionally normalize the new momentum by the ratio of norms before and after re-projection to preserve momentum mass.
We use ranks of $3$ and $6$, and an update frequency $T=10$ and plot mean and standard deviation across $5$ independent runs.
The results are presented in Figure 3.
As can be seen, the variant with state projection converges much faster.

## Appendix D LLaMA 7B pre-training results.

In this section, we present the results of pre-training a LLaMA 7b model on the C4 dataset for 120k iterations on 12B tokens.
See results in Table 14.
We conducted the training in pure bfloat16 with the density $\rho=0.0$.
We used learning rate $0.0005$ for state-full optimizer and $0.00015$ for state-free optimizer.
However, unlike Zhao et al. (), we didn’t use Adam8bit for state-full parameters but rather Adam, so it may not be an entirely fair comparison.
Nevertheless, the results show that FRUGAL has the potential for scaling up to 7B parameter models.

**Table 14: Pre-training LLaMA 7B on C4 dataset for 120K steps. Validation perplexity and memory estimate are reported. We also indicate the additional memory overhead introduced by the optimization algorithm.**
|  | 40K | 80K | 120K |
| --- | --- | --- | --- |
| 8-bit Adam | 18.09 | 15.47 | 14.83 |
| 8-bit GaLore | 17.94 | 15.39 | 14.95 |
| FRUGAL, $\rho=0.0$ | 17.56 | 14.50 | 13.49 |
| Tokens (B) | 5.2 | 10.5 | 15.7 |

## Appendix E Convergence Theory

Firstly, we provide ommited definition of $L$-smooth function.

###### Definition 1 .

We say that $f:\operatorname*{\mathbb{R}^{d}}\rightarrow\mathbb{R}$ is $L-$smooth with $L\geq 0$, if it is differentiable and satisfies

$$ $f(y)\leq f(x)+\langle\nabla f(x),y-x\rangle+\frac{L}{2}\|y-x\|^{2},\forall x,y \in\operatorname*{\mathbb{R}^{d}}.$ $$

Below, we provide an equivalent formulation of Algorithm 2 that enables us to use the proof of the similar structure to SGDM momentum analyis of Liu et al. ().

Figure: Algorithm 3 FRUGAL(SGDM, SGD): Equivalent to Algorithm 2 for constant step isze

Next, we present several key ingredients of the proof. Firstly, we can express the momentum term $\tilde{m}_{j}^{k}$
as

$$ $\displaystyle\tilde{m}_{j}^{k}$ $\displaystyle=(1-\beta)\sum_{i=t^{k}_{j}}^{k}\beta^{k-i}\tilde{g}_{j}^{i},$ (3) $$

where $t^{k}_{j}:=\max_{t\leq k}\{j\notin J_{t}\}$, i.e., the last time when the momentum buffer was released. We denote

$$ $\displaystyle m_{j}^{k}$ $\displaystyle=(1-\beta)\sum_{i=t^{k}_{j}}^{k}\beta^{k-i}g_{j}^{i},$ (4) $$

Using this notation, we proceed with two lemmas, one showing variance reduction effect of momentum, the other boundess of momentum bias.

###### Lemma 1 .

Under Assumption 1, the update vector $\tilde{m}^{k}$ in Algorithm 3 satisfies

$$ $\displaystyle\mathbb{E}\left[\left\|\tilde{m}^{k}-m^{k}\right\|^{2}\right]$ $\displaystyle\leq\frac{1-\beta}{1+\beta}\sigma^{2}.$ $$

###### Proof.

Since $\tilde{m}_{j}^{k}=(1-\beta)\sum_{i=t_{j}^{k}}^{k}\beta^{k-i}\tilde{g}_{j}^{i}$, we have

$$ $\displaystyle\mathbb{E}\left[\left\|\tilde{m}^{k}-m^{k}\right\|^{2}\right]$ $\displaystyle=\sum_{j\in[d]}\mathbb{E}\left[\left\|\tilde{m}_{j}^{k}-m_{j}^{k} \right\|^{2}\right]$ $\displaystyle\leq(1-\beta)^{2}\sum_{j\in[d]}\mathbb{E}\left[\left\|\sum_{i=t^{ k}_{j}}^{k}\beta^{k-i}(\tilde{g}_{j}^{i}-g_{j}^{i})\right\|^{2}\right].$ $$

Moreover, since $\zeta^{1},\zeta^{2},...,\zeta^{k}$ are independent random variables (item 3 of Assumption 1), we can use conditional expectation to show that $\mathbb{E}\left[(\tilde{g}_{j}^{i_{1}}-g_{j}^{i_{1}})(\tilde{g}_{j}^{i_{2}}-g_
{j}^{i_{2}})\right]=0$ for $i_{1}\neq i_{2}$. Therefore,

$$ $\displaystyle\mathbb{E}\left[\left\|\tilde{m}^{k}-m^{k}\right\|^{2}\right]$ $\displaystyle\leq(1-\beta)^{2}\sum_{j\in[d]}\mathbb{E}\left[\sum_{i=t^{k}_{j}} ^{k}\beta^{2(k-i)}\|\tilde{g}^{i}_{j}-g^{i}_{j}\|^{2}\right]$ $\displaystyle\leq\frac{1-\beta}{1+\beta}\sum_{j\in[d]}\mathbb{E}\left[(1-\beta ^{2(k-t^{k}_{j}+1)})\right]\sigma_{j}^{2}$ $\displaystyle\leq\frac{1-\beta}{1+\beta}\sum_{j\in[d]}\sigma_{j}^{2}=\frac{1- \beta}{1+\beta}\sigma^{2}.$ $$

∎

###### Lemma 2 .

Under Assumption 1, the update vector $\tilde{m}^{k}$ in Algorithm 3 further satisfies

$$ $\displaystyle\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\| \frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]\leq p^{k}_{ \max}\mathbb{E}\left[\sum_{i=1}^{k-1}a_{k,i}\|x^{i+1}-x^{i}\|^{2}\right],$ $$

where $k_{j}=k-t^{k}_{j}+1$, and

$$ $\displaystyle a_{k,i}=L^{2}\beta^{k-i}\left(k-i+\frac{\beta}{1-\beta}\right).$ (5) $$

###### Proof.

Let $\Pr_{k-1}[j\in J_{k}]=p^{k}_{j}$ and $p^{k}_{\max}:=\max_{j\in[d]}\{p^{k}_{j}\}$. Then,

$$ $\displaystyle\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\| \frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]$ $\displaystyle=\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\| \frac{1-\beta}{1-\beta^{k_{j}}}\sum_{i=t^{k}_{j}}^{k}\beta^{k-i}(g^{i}_{j}-g_{ j}^{k})\right\|^{2}\right]$ $\displaystyle=(1-\beta)^{2}\mathbb{E}\left[\sum_{j\in J_{k}}\sum_{i,l=t^{k}_{j }}^{k}\langle\beta^{k-i}(g^{k}_{j}-g^{i}_{j}),\beta^{k-l}(g^{k}_{j}-g^{l}_{j}) \rangle\right]$ $\displaystyle\leq(1-\beta)^{2}\mathbb{E}\left[\sum_{j\in J_{k}}\sum_{i,l=1}^{k }\beta^{2k-i-l}\left(\frac{1}{2}\|g_{j}^{k}-g_{j}^{i}\|^{2}]+\frac{1}{2}\|g_{j }^{k}-g_{j}^{l}\|^{2}\right)\right]$ $\displaystyle=(1-\beta)^{2}\mathbb{E}\left[\sum_{j\in J_{k}}\sum_{i=1}^{k} \left(\sum_{l=1}^{k}\beta^{2k-i-l}\right)\frac{1}{2}\mathbb{E}[\|g^{k}_{j}-g^{ l}_{j}\|^{2}\right]$ $\displaystyle\quad+(1-\beta)^{2}\mathbb{E}\left[\sum_{j\in J_{k}}\sum_{l=1}^{k }\left(\sum_{i=1}^{k}\beta^{2k-i-l}\right)\frac{1}{2}[\|g_{j}^{k}-g_{j}^{i}\|^ {2}\right]$ $\displaystyle=(1-\beta)^{2}\mathbb{E}\left[\sum_{j\in J_{k}}\sum_{i=1}^{k} \frac{\beta^{k-i}(1-\beta^{k_{j}})}{1-\beta}\|g_{j}^{k}-g_{j}^{i}\|^{2}\right]$ $\displaystyle\leq(1-\beta)\mathbb{E}\left[\sum_{j\in J_{k}}\sum_{i=1}^{k}\beta ^{k-i}\|g_{j}^{k}-g_{j}^{i}\|^{2}\right],$ $\displaystyle\leq(1-\beta)p^{k}_{\max}\mathbb{E}\left[\sum_{i=1}^{k}\beta^{k-i }\|g^{k}-g^{i}\|^{2}\right],$ $$

where we applied Cauchy-Schwarz to the first inequality.

By applying triangle inequality and the smoothness of $f$ (item 1 in Assumption 1), we further have

$$ $\displaystyle\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\| \frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]$ $\displaystyle\leq(1-\beta)p^{k}_{\max}\mathbb{E}\left[\sum_{i=1}^{k}\beta^{k-i }(k-i)\sum_{l=i}^{k-1}\|g^{l+1}-g^{l}\|^{2}\right]$ $\displaystyle\leq\mathbb{E}\left[\sum_{l=1}^{k-1}\left((1-\beta)p^{k}_{\max}L^ {2}\sum_{i=1}^{l}\beta^{k-i}(k-i)\right)\|x^{l+1}-x^{l}\|^{2}\right].$ $$

Therefore, by defining $a^{\prime}_{k,l}=(1-\beta)L^{2}\sum_{i=1}^{l}\beta^{k-i}(k-i)$, we get

$$ $\displaystyle\begin{split}&\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^ {2}\left\|\frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]\leq p ^{k}_{\max}\mathbb{E}\left[\sum_{l=1}^{k-1}a^{\prime}_{k,l}\|x^{l+1}-x^{l}\|^{ 2}\right].\end{split}$ (6) $$

Furthermore, $a^{\prime}_{k,j}$ can be calculated as

$$ $\displaystyle\begin{split}a^{\prime}_{k,l}&=L^{2}\beta^{k}\left(-(k-1)-\frac{1 }{1-\beta}\right)+L^{2}\beta^{k-l}\left(k-l+\frac{\beta}{1-\beta}\right).\end{split}$ (7) $$

Notice that

$$ $\displaystyle a^{\prime}_{k,l}<a_{k,l}\coloneqq L^{2}\beta^{k-l}\left(k-l+ \frac{\beta}{1-\beta}\right).$ (8) $$

Combining this with equation 6, we arrive at

$$ $\displaystyle\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\| \frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]\leq p^{k}_{ \max}\mathbb{E}\left[\sum_{i=1}^{k-1}a_{k,i}\|x^{i+1}-x^{i}\|^{2}\right],$ $$

where

$$ $\displaystyle a_{k,i}=L^{2}\beta^{k-i}\left(k-i+\frac{\beta}{1-\beta}\right).$ $$

∎

From Lemma 2, we know that the distance of the non-stochastic momentum from $g^{k}$ is bounded by the weighted sum of past successive iterate differences. Furthermore, the coefficients $a_{k,i}$ decays exponentially in $\beta$.

Therefore, we use the following Lyapunov function

$$ $\displaystyle L^{k}=\left(f(z^{k})-f^{\star}\right)+\sum_{i=1}^{k-1}c_{i}\|x^{ k+1-i}-x^{k-i}\|^{2}.$ (9) $$

for some positive $c_{i}$ that we specify later. As it is common for convergence theory of SGDM to analyze an auxiliary sequence $z^{k}$ defined as

$$ $\displaystyle z_{j}^{k}=\begin{cases}x_{j}^{k}&k=1,\\ \frac{1}{1-\beta}x_{j}^{k-\nicefrac{{1}}{{2}}}-\frac{\beta}{1-\beta}x_{j}^{k-1 }&\,k\geq 2,\end{cases}$ (10) $$

which behaves more like an SGD iterate, although the stochastic gradient $\tilde{g}^{k}$ is not taken at $z^{k}$.

###### Lemma 3 .

Let $x^{k}$’s be iterates of Algorithm 3, then $z^{k}$ defined in equation 10 satisfies

$$ $\displaystyle z^{k+1}-z^{k}$ $\displaystyle=-\alpha\tilde{g}^{k}.$ $$

###### Proof.

We have to consider two different cases.
Firstly, if $k=1$ or $j\notin J_{k}$, then

$$ $\displaystyle z^{k+1}_{j}-z^{k}_{j}$ $\displaystyle=\frac{x_{j}^{k+\nicefrac{{1}}{{2}}}}{1-\beta}-\frac{\beta x^{k}_ {j}}{1-\beta}-x^{k}_{j}=\frac{x^{k}_{j}-\alpha\tilde{m}_{j}^{k}-\beta x^{k}_{j }-(1-\beta)x^{k}_{j}}{1-\beta}=-\frac{\alpha(1-\beta)\tilde{g}_{j}^{k}}{1- \beta}=-\alpha\tilde{g}^{k}_{j}.$ $$

Secondly, if $k\geq 2$, $j\in J_{k}$, then

$$ $\displaystyle z_{j}^{k+1}-z_{j}^{k}$ $\displaystyle=\frac{1}{1-\beta}(x_{j}^{k+\nicefrac{{1}}{{2}}}-x_{j}^{k- \nicefrac{{1}}{{2}}})-\frac{\beta}{1-\beta}(x_{j}^{k}-x_{j}^{k-1})$ $\displaystyle=\frac{1}{1-\beta}(x_{j}^{k+\nicefrac{{1}}{{2}}}-x_{j}^{k})-\frac {\beta}{1-\beta}(x_{j}^{k}-x_{j}^{k-1})$ $\displaystyle=\frac{1}{1-\beta}(-\alpha\tilde{m}_{j}^{k})-\frac{\beta}{1-\beta }(-\alpha\tilde{m}_{j}^{k-1})$ $\displaystyle=\frac{1}{1-\beta}(-\alpha\tilde{m}_{j}^{k}+\alpha\beta\tilde{m}_ {j}^{k-1})=-\alpha\tilde{g}_{j}^{k}.$ $$

∎

Before procceding with the main convergence theory, we require one more proposition that shows descent in objective value.

###### Proposition 1 .

Take Assumption 1. Then, for $z^{k}$ defined in equation 10, we have

$$ $\displaystyle\begin{split}\mathbb{E}[f(z^{k+1})]&\leq\mathbb{E}[f(z^{k})]+ \left(-\alpha+\frac{1+\beta^{2}}{1-\beta}L\alpha^{2}+\frac{1}{2}L\alpha^{2} \right)\mathbb{E}[\|g^{k}\|^{2}]\\ &\quad+\left(\frac{\beta^{2}}{2(1+\beta)}+\frac{1}{2}\right)L\alpha^{2}\sigma^ {2}+\frac{L\alpha^{2}}{1-\beta}\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j }})^{2}\left\|\frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right] .\end{split}$ (11) $$

###### Proof.

The smoothness of $f$ yields

$$ $\displaystyle\begin{split}\mathbb{E}_{\zeta^{k}}[f(z^{k+1})]&\leq f(z^{k})+ \mathbb{E}_{\zeta^{k}}[\langle\nabla f(z^{k}),z^{k+1}-z^{k}\rangle]+\frac{L}{2 }\mathbb{E}_{\zeta^{k}}[\|z^{k+1}-z^{k}\|^{2}]\\ &=f(z^{k})+\mathbb{E}_{\zeta^{k}}[\langle\nabla f(z^{k}),-\alpha\tilde{g}^{k} \rangle]+\frac{L\alpha^{2}}{2}\mathbb{E}_{\zeta^{k}}[\|\tilde{g}^{k}\|^{2}], \end{split}$ (12) $$

where we have applied Lemma 3 in the second step.

For the inner product term, we can take full expectation $\mathbb{E}=\mathbb{E}_{\zeta^{1}}...\mathbb{E}_{\zeta^{k}}$ to get

$$ $\displaystyle\mathbb{E}[\langle\nabla f(z^{k}),-\alpha\tilde{g}^{k}\rangle]= \mathbb{E}[\langle\nabla f(z^{k}),-\alpha g^{k}\rangle],$ $$

which follows from the fact that $z^{k}$ is determined by the previous $k-1$ random samples $\zeta^{1},\zeta^{2},...\zeta^{k-1}$, which is independent of $\zeta^{k}$, and $\mathbb{E}_{\zeta^{k}}[\tilde{g}^{k}]=g^{k}$.

So, we can bound

$$ $\displaystyle\mathbb{E}[\langle\nabla f(z^{k}),-\alpha\tilde{g}^{k}\rangle]$ $\displaystyle=\mathbb{E}[\langle\nabla f(z^{k})-g^{k},-\alpha g^{k}\rangle]- \alpha\mathbb{E}[\|g^{k}\|^{2}]$ $\displaystyle\leq\alpha\frac{\rho_{0}}{2}L^{2}\mathbb{E}[\|z^{k}-x^{k}\|^{2}]+ \alpha\frac{1}{2\rho_{0}}\mathbb{E}[\|g^{k}\|^{2}]-\alpha\mathbb{E}[\|g^{k}\|^ {2}],$ $$

where $\rho_{0}>0$ can be any positive constant (to be determined later).

Combining equation 12 and the last inequality, we arrive at

$$ $\displaystyle\mathbb{E}[f(z^{k+1})]$ $\displaystyle\leq\mathbb{E}[f(z^{k})]+\alpha\frac{\rho_{0}}{2}L^{2}\mathbb{E}[ \|z^{k}-x^{k}\|^{2}]$ $\displaystyle\quad+(\alpha\frac{1}{2\rho_{0}}-\alpha)\mathbb{E}[\|g^{k}\|^{2}] +\frac{L\alpha^{2}}{2}\mathbb{E}[\|\tilde{g}^{k}\|^{2}].$ $$

By construction, $z_{j}^{k}-x_{j}^{k}=-\frac{\beta}{1-\beta}\alpha\tilde{m}_{j}^{k-1}$ for $j\in J_{k}$, 0 otherwise. Consequently,

$$ $\displaystyle\begin{split}\mathbb{E}[f(z^{k+1})]&\leq\mathbb{E}[f(z^{k})]+ \alpha^{3}\frac{\rho_{0}}{2}L^{2}(\frac{\beta}{1-\beta})^{2}\mathbb{E}\left[ \sum_{j\in J_{k}}\|\tilde{m}_{j}^{k-1}\|^{2}\right]\\ &\quad+(\alpha\frac{1}{2\rho_{0}}-\alpha)\mathbb{E}[\|g^{k}\|^{2}]+\frac{L \alpha^{2}}{2}\mathbb{E}[\|\tilde{g}^{k}\|^{2}].\end{split}$ (13) $$

Let $k_{j}=k-t^{k-1}_{j}+1$. Then, from Lemma 1 we know that

$$ $\displaystyle\begin{split}\mathbb{E}\left[\sum_{j\in J_{k}}\|\tilde{m}_{j}^{k- 1}\|^{2}\right]&\leq 2\mathbb{E}\left[\sum_{j\in J_{k}}\|\tilde{m}_{j}^{k-1}-m _{j}^{k-1}\|^{2}\right]+2\mathbb{E}\left[\sum_{j\in J_{k}}\|m_{j}^{k-1}\|^{2} \right]\\ &\leq 2\frac{1-\beta}{1+\beta}\mathbb{E}\left[\sum_{j\in J_{k}}\sigma_{j}^{2}+ 2\sum_{j\in J_{k}}\|m_{j}^{k-1}\|^{2}\right]\\ \mathbb{E}\left[\sum_{j\in J_{k}}\|m_{j}^{k-1}\|^{2}\right]&=\mathbb{E}\left[ \sum_{j\in J_{k}}(1-\beta^{(k-1)_{j}})^{2}\left\|\frac{m_{j}^{k-1}}{(1-\beta^{ (k-1)_{j}})}\right\|^{2}\right]\\ &\leq 2\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{(k-1)_{j}})^{2}\left\|\frac{ m_{j}^{k-1}}{(1-\beta^{(k-1)_{j}})}-g_{j}^{k}\right\|^{2}\right]+2\mathbb{E} \left[\sum_{j\in J_{k}}\left\|g_{j}^{k}\right\|^{2}\right]\\ \mathbb{E}\left[\|\tilde{g}^{k}\|^{2}\right]&\leq\sigma^{2}+\mathbb{E}[\|g^{k} \|^{2}].\end{split}$ (14) $$

Putting these into equation 13, we arrive at

$$ $\displaystyle\mathbb{E}[f(z^{k+1})]$ $\displaystyle\leq\mathbb{E}[f(z^{k})]+\bigg{(}-\alpha+\alpha\frac{1}{2\rho_{0} }+2\alpha^{3}\rho_{0}L^{2}\left(\frac{\beta}{1-\beta}\right)^{2}+\frac{L\alpha ^{2}}{2}\bigg{)}\mathbb{E}[\|g^{k}\|^{2}]$ $\displaystyle\quad+\left(\alpha^{3}{\rho_{0}}L^{2}\left(\frac{\beta}{1-\beta} \right)^{2}\frac{1-\beta}{1+\beta}\sigma^{2}+\frac{L\alpha^{2}}{2}\sigma^{2}\right)$ $\displaystyle\quad+2\alpha^{3}\rho_{0}L^{2}\left(\frac{\beta}{1-\beta}\right)^ {2}\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{(k-1)_{j}})^{2}\left\|\frac{m_{j }^{k-1}}{(1-\beta^{(k-1)_{j}})}-g_{j}^{k}\right\|^{2}\right].$ $$

Notice that if $j\in J^{k}$, then $(k-1)_{j}=k_{j}-1$. Therefore,

$$ $\displaystyle\mathbb{E}\left[\left\|\frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^ {k}\right\|^{2}\right]$ $\displaystyle=\mathbb{E}\left[\left\|\frac{\beta m_{j}^{k-1}+(1-\beta)g^{k}_{j }}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]$ $\displaystyle=\beta^{2}\mathbb{E}\left[\left(\frac{(1-\beta^{k_{j}-1})}{(1- \beta^{k_{j}})}\right)^{2}\left\|\frac{m_{j}^{k-1}}{(1-\beta^{(k-1)_{j}})}-g_{ j}^{k}\right\|^{2}\right].$ $$

Substituting the above into the last inequality produces

$$ $\displaystyle\begin{split}\mathbb{E}[f(z^{k+1})]&\leq\mathbb{E}[f(z^{k})]+ \bigg{(}-\alpha+\alpha\frac{1}{2\rho_{0}}+2\alpha^{3}\rho_{0}L^{2}(\frac{\beta }{1-\beta})^{2}+\frac{L\alpha^{2}}{2}\bigg{)}\mathbb{E}[\|g^{k}\|^{2}]\\ &\quad+\left(\alpha^{3}{\rho_{0}}L^{2}(\frac{\beta}{1-\beta})^{2}\frac{1-\beta }{1+\beta}\sigma^{2}+\frac{L\alpha^{2}}{2}\sigma^{2}\right)\\ &\quad+2\alpha^{3}\rho_{0}L^{2}\left(\frac{1}{1-\beta}\right)^{2}\mathbb{E} \left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\|\frac{m_{j}^{k}}{(1-\beta^{ k_{j}})}-g_{j}^{k}\right\|^{2}\right].\end{split}$ (15) $$

Finally, $\rho_{0}=\frac{1-\beta}{2L\alpha}$ gives

$$ $\displaystyle\begin{split}\mathbb{E}[f(z^{k+1})]&\leq\mathbb{E}[f(z^{k})]+ \left(-\alpha+\frac{1+\beta^{2}}{1-\beta}L\alpha^{2}+\frac{1}{2}L\alpha^{2} \right)\mathbb{E}[\|g^{k}\|^{2}]\\ &\quad+\left(\frac{\beta^{2}}{2(1+\beta)}+\frac{1}{2}\right)L\alpha^{2}\sigma^ {2}+\frac{L\alpha^{2}}{1-\beta}\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j }})^{2}\left\|\frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right] .\end{split}$ $$

∎

###### Definition 1 .

###### Lemma 1 .

###### Proof.

###### Lemma 2 .

###### Proof.

###### Lemma 3 .

###### Proof.

###### Proposition 1 .

###### Proof.

### E.1 Convergence of Algorithm 3

Firstly, by combining results from prior section, we can bound our Lyapunov function $L^{k}$ defined in equation 9.

###### Proposition 2 .

Let Assumption 1 hold and $\alpha\leq\frac{1-\beta}{2\sqrt{2}L\sqrt{p^{k}_{\max}}\sqrt{\beta+\beta^{2}}}$ in Algorithm 3. Let $\{c_{i}\}_{i=1}^{\infty}$ in equation 9 be defined by

$$ $\displaystyle c_{1}$ $\displaystyle=\frac{\frac{\beta+\beta^{2}}{(1-\beta)^{3}}L^{3}\alpha^{2}}{1-4 \alpha^{2}\frac{\beta+\beta^{2}}{(1-\beta)^{2}}L^{2}},\quad\quad c_{i+1}=c_{i} -\left(4c_{1}\alpha^{2}+\frac{L\alpha^{2}}{1-\beta}\right)\beta^{i}(i+\frac{ \beta}{1-\beta})L^{2}\quad\text{for all $i\geq 1$.}$ $$

Then, $c_{i}>0$ for all $i\geq 1$, and

$$ $\displaystyle\begin{split}\mathbb{E}[L^{k+1}-L^{k}]&\leq\left(-\alpha+\frac{3- \beta+\beta^{2}}{2(1-\beta)}L\alpha^{2}+4c_{1}\alpha^{2}\right)\mathbb{E}[\|g^ {k}\|^{2}]\\ &\quad+\left(\frac{\beta^{2}}{2(1+\beta)}L\alpha^{2}\sigma^{2}+\frac{1}{2}L \alpha^{2}\sigma^{2}+2c_{1}\alpha^{2}\sigma^{2}\right).\end{split}$ (16) $$

###### Proof.

Recall that $L^{k}$ is defined as

$$ $L^{k}=f(z^{k})-f^{*}+\sum_{i=1}^{k-1}c_{i}\|x^{k+1-i}-x^{k-i}\|^{2},$ $$

Therefore, by equation 15 we know that

$$ $\displaystyle\begin{split}&\mathbb{E}[L^{k+1}-L^{k}]\leq\\ &\quad(-\alpha+\frac{1+\beta^{2}}{1-\beta}L\alpha^{2}+\frac{1}{2}L\alpha^{2}) \mathbb{E}[\|g^{k}\|^{2}]\\ &\quad+\sum_{i=1}^{k-1}(c_{i+1}-c_{i})\mathbb{E}[\|x^{k+1-i}-x^{k-i}\|^{2}]+c_ {1}\mathbb{E}[\|x^{k+1}-x^{k}\|^{2}]\\ &\quad+\left(\frac{\beta^{2}}{2(1+\beta)}+\frac{1}{2}\right)L\alpha^{2}\sigma^ {2}+\frac{L\alpha^{2}}{1-\beta}\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j }})^{2}\left\|\frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right] .\end{split}$ (17) $$

To bound the $c_{1}\mathbb{E}[\|x^{k+1}-x^{k}\|^{2}]$ term, we need the following inequalities, which are obtained similarly as equation 14.

$$ $\displaystyle\begin{split}\mathbb{E}[\|\tilde{m}^{k}\|^{2}]&\leq 2\frac{1- \beta}{1+\beta}\sigma^{2}+2\mathbb{E}[\|m^{k}\|^{2}]\\ \mathbb{E}[\|m^{k}\|^{2}]&\leq 2\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{ j}})^{2}\left\|\frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right ]+2\mathbb{E}\left[\left\|g^{k}\right\|^{2}\right]\\ \mathbb{E}[\|\tilde{g}^{k}\|^{2}]&\leq\sigma^{2}+\mathbb{E}[\|g^{k}\|^{2}]. \end{split}$ (18) $$

Let $\Pr_{k-1}[j\in J_{k}]=p^{k}_{j}$ and $p^{k}_{\min}:=\min_{j\in[d]}\{p^{k}_{j}\}$. Then, $c_{1}\mathbb{E}[\|x^{k+1}-x^{k}\|^{2}]$ can be bounded as

$$ $\displaystyle c_{1}\mathbb{E}[\|x^{k+1}-x^{k}\|^{2}]$ $\displaystyle=c_{1}\alpha^{2}\mathbb{E}[\|\tilde{u}^{k}\|^{2}]=c_{1}\alpha^{2} \mathbb{E}\left[\sum_{j\in J_{k}}\|\tilde{m}_{j}^{k}\|^{2}+\sum_{j\notin J_{k} }\|\tilde{g}_{j}^{k}\|^{2}\right]$ $\displaystyle\leq c_{1}\alpha^{2}\mathbb{E}\left[\|\tilde{m}^{k}\|^{2}+(1-p^{k }_{\min})\|\tilde{g}^{k}\|^{2}\right]$ $\displaystyle\leq c_{1}\alpha^{2}\left(\left(2\frac{1-\beta}{1+\beta}+1-p^{k}_ {\min}\right)\sigma^{2}+5\mathbb{E}[\|g^{k}\|^{2}]\right)$ $\displaystyle\quad+4c_{1}\alpha^{2}\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{ k_{j}})^{2}\left\|\frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]$ $$

Combine this with equation 17, we obtain

$$ $\displaystyle\begin{split}&\mathbb{E}[L^{k+1}-L^{k}]\\ &\leq(-\alpha+\frac{1+\beta^{2}}{1-\beta}L\alpha^{2}+\frac{1}{2}L\alpha^{2}+5c _{1}\alpha^{2})\mathbb{E}[\|g^{k}\|^{2}]+\left(\frac{\beta^{2}}{2(1+\beta)}+ \frac{1}{2}+\frac{c_{1}}{L}\left(2\frac{1-\beta}{1+\beta}+1-p^{k}_{\min}\right )\right)L\alpha^{2}\sigma^{2}\\ &\quad+\sum_{i=1}^{k-1}(c_{i+1}-c_{i})\mathbb{E}[\|x^{k+1-i}-x^{k-i}\|^{2}]\\ &\quad+\left(4c_{1}\alpha^{2}+\frac{L\alpha^{2}}{1-\beta}\right)\mathbb{E} \left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\|\frac{m_{j}^{k}}{(1-\beta^{ k_{j}})}-g_{j}^{k}\right\|^{2}\right].\end{split}$ (19) $$

In the rest of the proof, let us show that the sum of the last two terms in equation 19 is non-positive.

First of all, by Lemma 2 we know that

$$ $\displaystyle\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\| \frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]\leq\mathbb{E} \left[p^{k}_{\max}\sum_{i=1}^{k-1}a_{k,i}\|x^{i+1}-x^{i}\|^{2}\right],$ $$

where

$$ $\displaystyle a_{k,i}=L^{2}\beta^{k-i}\left(k-i+\frac{\beta}{1-\beta}\right).$ $$

Or equivalently,

$$ $\displaystyle\mathbb{E}\left[\sum_{j\in J_{k}}(1-\beta^{k_{j}})^{2}\left\| \frac{m_{j}^{k}}{(1-\beta^{k_{j}})}-g_{j}^{k}\right\|^{2}\right]\leq\mathbb{E} \left[\sum_{i=1}^{k-1}p^{k}_{\max}a_{k,k-i}\|x^{k+1-i}-x^{k-i}\|^{2}\right],$ $$

where

$$ $\displaystyle a_{k,k-i}=L^{2}\beta^{i}\left(i+\frac{\beta}{1-\beta}\right).$ $$

Therefore, to make the sum of the last two terms of equation 19 to be non-positive, we need to have

$$ $\displaystyle c_{i+1}$ $\displaystyle\leq c_{i}-\left(4c_{1}\alpha^{2}+\frac{L\alpha^{2}}{1-\beta} \right)L^{2}p^{i}_{\max}\beta^{i}\left(i+\frac{\beta}{1-\beta}\right)$ $$

for all $i\geq 1$.
To satisfy this inequality, we choose

$$ $\displaystyle c_{i+1}$ $\displaystyle=c_{i}-\left(4c_{1}\alpha^{2}+\frac{L\alpha^{2}}{1-\beta}\right)L ^{2}\beta^{i}p^{i}_{\max}\left(i+\frac{\beta}{1-\beta}\right)$ $$

for all $i\geq 1$, which implies that

$$ $\displaystyle c_{i}$ $\displaystyle=c_{1}-\left(4c_{1}\alpha^{2}+\frac{L\alpha^{2}}{1-\beta}\right)L ^{2}\sum_{l=1}^{i-1}\beta^{i}p^{i}_{\max}\left(i+\frac{\beta}{1-\beta}\right).$ $$

To have $c_{i}>0$ for all $i\geq 1$, we can set $c_{1}$ as

$$ $\displaystyle c_{1}$ $\displaystyle=\left(4c_{1}\alpha^{2}+\frac{L\alpha^{2}}{1-\beta}\right)L^{2} \hat{p}^{k}_{\max}\sum_{i=1}^{\infty}\beta^{i}\left(i+\frac{\beta}{1-\beta} \right).$ $$

where, $\hat{p}^{k}_{\max}=\max_{i\in[k]}\{p^{i}_{\max}\}$. Since

$$ $\sum_{i=1}^{j}i\beta^{i}=\frac{1}{1-\beta}\left(\frac{\beta(1-\beta^{j})}{1- \beta}-j\beta^{j+1}\right),$ $$

we have $\sum_{i=1}^{\infty}i\beta^{i}=\frac{\beta}{(1-\beta)^{2}}$ and

$$ $\displaystyle c_{1}=\left(4c_{1}\alpha^{2}+\frac{L\alpha^{2}}{1-\beta}\right)L ^{2}\hat{p}^{k}_{\max}\frac{\beta+\beta^{2}}{(1-\beta)^{2}},$ $$

which implies that

$$ $\displaystyle c_{1}=\frac{\alpha^{2}L^{3}\hat{p}^{k}_{\max}\frac{\beta+\beta^{ 2}}{(1-\beta)^{3}}}{1-4\alpha^{2}\frac{\beta+\beta^{2}}{(1-\beta)^{2}}\hat{p}^ {k}_{\max}L^{2}}.$ (20) $$

Notice that $\alpha\leq\frac{1-\beta}{2\sqrt{2}L\sqrt{\hat{p}^{k}_{\max}}\sqrt{\beta+\beta^
{2}}}$ ensures $c_{1}>0$.

Therefore,

$$ $\displaystyle\mathbb{E}[L^{k+1}-L^{k}]$ $\displaystyle\leq\left(-\alpha+\frac{3-\beta+2\beta^{2}}{2(1-\beta)}L\alpha^{2 }+5c_{1}\alpha^{2}\right)\mathbb{E}[\|g^{k}\|^{2}]$ $\displaystyle\quad+\left(\frac{\beta^{2}}{2(1+\beta)}L\alpha^{2}\sigma^{2}+ \frac{1}{2}L\alpha^{2}\sigma^{2}+c_{1}\alpha^{2}\sigma^{2}\left(2\frac{1-\beta }{1+\beta}+1-p^{k}_{\min}\right)\right).$ $$

∎

By telescoping equation 16, we obtain the convergence bound of our proposed algorithm under nonconvex settings.

###### Theorem 2 .

Let Assumption 1 hold and $\alpha^{k}=\alpha\leq\frac{1-\beta}{L(4-\beta+\beta^{2})}$. Then, the iterates of Algorithm 3 satisfy

$$ $\displaystyle\frac{1}{k}\sum_{i=1}^{k}\mathbb{E}[\|g^{i}\|^{2}]$ $\displaystyle\leq\mathcal{O}\left(\frac{f(x^{1})-f^{*}}{k\alpha}+L\alpha\sigma ^{2}\left(1+\frac{\hat{p}^{k}_{\max}(1-\bar{p}^{k}_{\min})\beta}{(1-\beta)} \right)\right),$ (21) $$

where $\bar{p}^{k}_{\min}=\frac{1}{k}\sum_{i=1}^{k}\bar{p}^{i}_{\min}$ and $\hat{p}^{k}_{\max}=\max_{i\in[k]}\{p^{i}_{\max}\}$.

###### Proof.

From equation 16 we know that

$$ $\displaystyle\begin{split}\mathbb{E}[L^{k+1}-L^{k}]\leq-R_{1}\mathbb{E}[\|g^{k }\|^{2}]+R^{k}_{2},\end{split}$ (22) $$

where

$$ $\displaystyle R_{1}$ $\displaystyle=-\alpha+\frac{3-\beta+\beta^{2}}{2(1-\beta)}L\alpha^{2}+4c_{1} \alpha^{2},$ $\displaystyle R_{2}$ $\displaystyle=\frac{\beta^{2}}{2(1+\beta)}L\alpha^{2}\sigma^{2}+\frac{1}{2}L \alpha^{2}\sigma^{2}+c_{1}\alpha^{2}\sigma^{2}\left(2\frac{1-\beta}{1+\beta}+1 -p^{k}_{\min}\right).$ $$

We further define

$$ $\displaystyle\bar{R}_{2}$ $\displaystyle=\frac{\beta^{2}}{2(1+\beta)}L\alpha^{2}\sigma^{2}+\frac{1}{2}L \alpha^{2}\sigma^{2}+c_{1}\alpha^{2}\sigma^{2}\left(2\frac{1-\beta}{1+\beta}+1 -\bar{p}^{k}_{\min}\right),$ $$

where $\bar{p}^{k}_{\min}=\frac{1}{k}\sum_{i=1}^{k}\bar{p}^{i}_{\min}.$

Telescoping equation 22 yields

$$ $\displaystyle L^{1}\geq\mathbb{E}[L^{1}-L^{k+1}]\geq R_{1}\sum_{i=1}^{k} \mathbb{E}[\|g^{i}\|^{2}]-\sum_{k=1}^{k}R^{k}_{2},$ $$

and therefore

$$ $\displaystyle\frac{1}{k}\sum_{i=1}^{k}\mathbb{E}[\|g^{i}\|^{2}]\leq\frac{L^{1} }{kR_{1}}+\frac{\bar{R}_{2}}{R_{1}}.$ (23) $$

In the rest of the proof, we will appropriately bound $R_{1}$ and $\bar{R}_{2}$.

First, let us show that $R_{1}\geq\frac{\alpha}{2}$ and $\alpha\leq\min\left\{\frac{1-\beta}{L(4-\beta+\beta^{2})},\frac{1-\beta}{2
\sqrt{2}L\sqrt{\hat{p}^{k}_{\max}}\sqrt{\beta+\beta^{2}}}\right\}$.

From equation 20 we know that

$$ $\displaystyle c_{1}=\frac{\alpha^{2}L^{3}\hat{p}^{k}_{\max}\frac{\beta+\beta^{ 2}}{(1-\beta)^{3}}}{1-4\alpha^{2}\frac{\beta+\beta^{2}}{(1-\beta)^{2}}L^{2} \hat{p}^{k}_{\max}}.$ $$

Since $\alpha\leq\frac{1-\beta}{2\sqrt{2}L\sqrt{\hat{p}^{k}_{\max}}\sqrt{\beta+\beta^
{2}}}$, we have

$$ $\displaystyle 4\alpha^{2}\frac{\beta+\beta^{2}}{(1-\beta)^{2}}L^{2}\hat{p}^{k} _{\max}\leq\frac{1}{2}.$ $$

Thus,

$$ $\displaystyle c_{1}$ $\displaystyle\leq\alpha^{2}L^{3}\hat{p}^{k}_{\max}\frac{\beta+\beta^{2}}{(1- \beta)^{3}}\leq\frac{L}{8(1-\beta)}.$ $$

Therefore, in order to ensure $R_{1}\geq\frac{\alpha}{2}$, it suffices to have

$$ $\displaystyle\frac{3-\beta+\beta^{2}}{2(1-\beta)}L\alpha+\frac{\alpha L}{2(1- \beta)}\leq\frac{1}{2}$ $$

which is equivalent to our condition $\alpha\leq\frac{1-\beta}{L(4-\beta+\beta^{2})}$.

For $\bar{R}_{2}$, we can upperbound $c_{1}$ using our condition $\alpha\leq\frac{1-\beta}{L(4-\beta+\beta^{2})}$. Thus,

$$ $\displaystyle c_{1}$ $\displaystyle\leq\alpha^{2}L^{3}\hat{p}^{k}_{\max}\frac{\beta+\beta^{2}}{(1- \beta)^{3}}\leq\frac{\hat{p}^{k}_{\max}\beta L}{2(1-\beta)}.$ $$

Therefore,

$$ $\displaystyle\bar{R}_{2}$ $\displaystyle=\frac{\beta^{2}}{2(1+\beta)}L\alpha^{2}\sigma^{2}+\frac{1}{2}L \alpha^{2}\sigma^{2}+c_{1}\alpha^{2}\sigma^{2}\left(2\frac{1-\beta}{1+\beta}+1 -\bar{p}^{k}_{\min}\right)$ $\displaystyle\leq\frac{\beta^{2}}{2(1+\beta)}L\alpha^{2}\sigma^{2}+\frac{1}{2} L\alpha^{2}\sigma^{2}+\frac{\hat{p}^{k}_{\max}\beta L\alpha^{2}\sigma^{2}}{(1+ \beta)}+L\alpha^{2}\sigma^{2}\hat{p}^{k}_{\max}(1-\bar{p}^{k}_{\min})\frac{ \beta}{1-\beta}$ $\displaystyle\leq\left(\frac{2\beta^{2}+8\hat{p}^{k}_{\max}}{2(1+\beta)}+\frac {1}{2}+\frac{\hat{p}^{k}_{\max}(1-\bar{p}^{k}_{\min})\beta}{8(1-\beta)}\right) L\alpha^{2}\sigma^{2}.$ $$

By putting them all together, we obtain

$$ $\displaystyle\begin{split}\frac{1}{k}\sum_{i=1}^{k}\mathbb{E}[\|g^{i}\|^{2}]& \leq\frac{2\left(f(x^{1})-f^{*}\right)}{k\alpha}+\left(\frac{2\beta^{2}+8\hat{ p}^{k}_{\max}}{2(1+\beta)}+\frac{1}{2}+\frac{\hat{p}^{k}_{\max}(1-\bar{p}^{k}_ {\min})\beta}{8(1-\beta)}\right)L\alpha\sigma^{2}\\ &=\mathcal{O}\left(\frac{f(x^{1})-f^{*}}{k\alpha}+L\alpha\sigma^{2}\left(1+ \frac{\hat{p}^{k}_{\max}(1-\bar{p}^{k}_{\min})\beta}{(1-\beta)}\right)\right). \end{split}$ $$

∎

###### Proposition 2 .

###### Proof.

###### Theorem 2 .

###### Proof.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: GaLore theoretically prove that gradient is low-rank and a study in BlockLLM (https://arxiv.org/pdf/2406.17296)  show that only a few parameters are updated during the training. A few other recent works also seem to suggest that the low rank structure exists in the network. But this paper seems to suggest the opposite. Do you see a space where these two ideas coexist? For example, low rank for certain tasks vs full rank for other tasks? 

Minor:
- Introduce abbreviations for better readability. For example SGD as Stochastic Gradient Descent. 
- Missing references Adam-mini and BlockLLM
soundness: 2
strengths: 1. The combination of state-free optimizers with advanced ones, like SGD and Adam, for memory efficient training is a novel idea.
2. The  empirical results show that FRUGAL does better than other methods in terms of memory use and perplexity,
3. The paper includes sufficient ablation studies and it helps to see how FRUGAL works in different situations and settings.
summary: The work proposes a memory efficient training method called FRUGAL which is essentially a combination of full-rank updates with gradient splitting. The authors partition the parameters and update using advanced optimizers (like Adam) for low-dimensional updates and state-free methods (like SGD or signSGD) for remaining directions. Additionally, the authors provide theoretical convergence guarantees and validate FRUGAL’s effectiveness through experiments on models like LLaMA.
weaknesses: Line 249 introduces state-free and stateful parameters but could provide more explicit explanation on the selection criteria. Are parameters randomly selected to each category? In that case the assumption is all the parameters are equally important for that iteration. The work could benefit from more detailed study on how to choose the parameters for state free updates. 

The purpose of the density parameter ($\rho$) is not thoroughly explained, especially in relation to zero-density training. Please clarify whether zero-density training implies all parameters are state-free (i.e., trained exclusively with SGD). The selection of $\rho$ is not mentioned in the algorithm as well.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 1
questions: - 1) Including more experiments comparing the method with various stateful and stateless optimizers would enhance the paper. 

- 2) Testing models with larger sizes (e.g., 3B and 7B) could further demonstrate the generalizability of the proposed method. 

- 3) Please clarify the reasons for selecting the specific optimizers in the theoretical section. They appear restrictive and differ from those used in the main algorithm. Additional details and guarantees would help generalize this proof. 

- 4) While it’s mentioned that stateless optimizers typically underperform with transformer architectures, the paper doesn’t explain why FRUGAL with $\rho=0$ achieves optimal performance in certain scenarios. Providing more details and comparisons would clarify this.
Expanding the dataset and incorporating diverse architectures could strengthen the argument for FRUGAL's superior characteristics.
soundness: 3
strengths: -1) The paper presents a novel approach to improving memory efficiency while performing updates using full-rank information. 
-2) The proposed method is flexible, supporting various choices for both stateful and stateless optimizers as well as different projection methods. It offers convergence guarantees for FRUGAL within a specified framework and consistently outperforms existing memory-efficient algorithms, such as GaLore and BAdam, achieving performance levels close to the memory-intensive Adam optimizer. 
-3) Additionally, the paper provides valuable insights into the learning dynamics of transformer models.
summary: This paper introduces FRUGAL (Full-Rank Updates with GrAdient spLitting) that reduces memory consumption by splitting gradient updates into two subspaces. A *state-full* subspace is updated using advanced optimization algorithms like Adam, while a *state-free* subspace is updated using stateless and memory-efficient methods like SGD or signSGD. The framework allows for a flexible choice of optimizers and projection methods. FRUGAL achieves state-of-the-art results in pre-training and fine-tuning tasks, outperforming existing memory-efficient algorithms while maintaining a similar memory budget.
weaknesses: -1) The paper's structure would greatly benefit from a clearer organization. Currently, some analysis and experimental results appear within the Methods section, which disrupts the logical flow and makes it challenging for readers to follow the methodology. Reorganizing the paper and dedicating specific sections to distinct aspects of the research could significantly enhance readability and impact.

-2) Several notations (e.g., g~) are introduced without proper definitions, which assumes too much prior knowledge from readers. Additionally, concepts like smoothness and unbiasedness are only vaguely referenced and would benefit from clearer definitions. The theory section should be expanded to explicitly define each notation and assumption, as well as to contextualize them within a more general setting relevant to the proposed method.

-3) Including a full-parameter fine-tuning baseline in Table 4 would provide a valuable benchmark, offering a clearer context for evaluating the results.

-4) Definitions for Full-Rank SVD/Random and Low-Rank SVD/Random are scattered across Table 1 and lack clear differentiation. Consolidating these explanations into a concise paragraph would improve clarity and reader comprehension.

-5) Lastly, there are deviations from the primary algorithm, such as using column-wise projection instead of block-wise projection. For completeness, it would be beneficial to include results using the original proposed approach alongside the variations in the experiments.

-6) By solving this issues in the revision, especially following a more structured writing style and lowering the jumps, the paper would definitely level up.

---

confidence: 2
contribution: 4
initial_rating: 6
presentation: 3
questions: **Formal Definitions of Full and Free States:** Could the authors provide formal definitions of "full" and "free" states as used in the method? A clearer understanding of these terms would improve the paper’s theoretical foundation.

**Main Limitations:** What are the primary limitations of this approach? A discussion on the constraints or situations where the method might be less effective would help clarify its scope and potential trade-offs.

**Running Time Comparisons:** Beyond memory efficiency, how does the method’s running time compare to that of other baseline approaches? Performance in terms of speed is crucial for practical deployment, so direct comparisons would provide a more complete picture of the method’s efficiency.
soundness: 3
strengths: **Well-structured Presentation:** The paper is well-structured and easy to follow, with a clear presentation of concepts and methodology.

**Practical Impact:** The method is straightforward to implement and has broad applicability, making it valuable for practical use in various settings.
summary: This paper introduces a novel memory-efficient optimization method. Unlike other state-of-the-art approaches, such as LoRA and GaLore, that have low-rank updates, this method maintains a full-rank update structure. The experimental results demonstrate its superior performance, highlighting its potential advantages in both efficiency and effectiveness over competing methods.
weaknesses: **Lack of Discussion on Limitations:** The paper would benefit from a discussion of the method's limitations and potential failure modes. Addressing these aspects would provide a more balanced view of the approach's applicability and constraints.

**Vague Terminology:** Given the importance of "state-full" and "state-free" in the proposed method, the paper should offer clearer definitions of these terms. Precise terminology is essential to fully understand the mechanics and implications of the approach.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: Please refer to the weakness
soundness: 3
strengths: - Plenty of experiments are conducted to evaluate FRUGAL where FRUGAL demonstrates significant improvments against GaLore.

- Both empirical and theoretically justification are provided to validate the effectiveness of FRUGAL.
summary: This work proposed a new memory-efficient training methods that allows part of the parameters being optimization with optimization states within a compact space while other parameters are optimizated in the original space without optimization states. Results on serveral pre-training and fine-tuning tasks demonstrates the effectiveness of the proposed methods.
weaknesses: - The GLUE benchmarks is little bit outdated, more recent tasks like common-sense reasoning, mt-bench would further improve this work.

- Is there any explanations about which part of the parameters can be directly optimized with SGD type optimizer with other requires adam and why?

- For $\rho=0$ in Table 2, is it equals to fully optimized with SGD? Does it controdict with recent works that demonstrates that transformers can not be effectively optimzied with SGD? [1]

- The concepts of state-full and state-free subspace in line80/82 is hard to understand, it's better to formally define these two concepts. 

- line 192: "Surprisingly, we found that although SVD decomposition delivers an initial boost, subsequent training with random projection yields significant improvements", this sequence make it a little bit confusing whether the "Low-rank Random" in Table 1 is training of entire random projection or first SVD and later random.

- it's better to define the meaning of K in the inputs of algorithm 1, as well as s.


[1] Why Transformers Need Adam: A Hessian Perspective

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 2
questions: I don't have other questions. All major weaknesses are listed above.
soundness: 3
strengths: 1. FRUGAL's convergence rate is provided and it can recover the rate of standard SGD(M). 

2. The experiment execution is strong and the results are convincing. The hyperparameter details are well disclosed and the implementation is provided.
summary: This paper introduces FRUGAL. The fundamental idea is that during the backward pass, we will take a subset of parameters (a block) to perform stateful Adam updates and for the rest parameters (with blockwise selection) or the gradient residuals (with low-rank gradient projection), we use stateless signSGD updates. The memory efficiency of FRUGAL is achieved by reducing the optimizer states. The authors provide a convergence rate similar to SGD momentum's usual rate under nonconvex optimization. The authors also perform experiments with Llama pretraining on C4 and RoBerta-base fine-tuning on GLUE tasks. The baselines are primarily Galore and BAdam.
weaknesses: **Major concern**:

1. The idea of FRUGAL is fairly simple (as a combination of signSGD, Adam, and a gradient projector) but the empirical and theoretical support behind FRUGAL is not solid enough. FRUGAL's stateful optimizer is basically either Galore or BAdam. The main contribution is therefore stateless optimizer part (signSGD), and such effectivenss relies on the finding that stateless optimizers are sufficient to optimize most parameters in LLM (linear weight matrices). The authors only provide a single ablation study in Table 3 without further empirical or theoretical insights on the stateless optimizer part. This evidence alone is not convincing enough on an assured generalization to other non-Llama architectures. So it appears to me that the contribution of this paper is insufficient for an ICLR paper. 

2. The motivation (Figure 2) of FRUGAL is that low-rank gradient projection is similar, and random or blockwise selection can cover the whole space. Figure 2 justifies that the top gradient directions across timestep is similar, but *is insufficient to show that random or blockwise selection is always/necessarily better. It is highly likely that after a certain threshold, the role of randomly selected parameters/blocks of parameters have worse performance than top gradient directions. An ablation study on projector type versus stateful optimization density $\rho$ is definitely needed.

**Minor concern**:

1. The presentation of the Algorithm needs to be clearer. It is hard to understand the exact algorithm (which is actually simple) in the first time of reading Algorithm 1 and Section 3.


I consider the first major weakness as critical and I would vote for a borderline reject score at this moment.

Meta-review: This paper proposes FRUGAL, a memory-efficient optimization framework that aims to provide full-rank updates for large language model (LLM) training by splitting parameters into those updated with stateful optimizers (e.g., Adam) and those updated with state-free methods (e.g., signSGD). The authors offer theoretical convergence guarantees and present empirical evaluations that, at face value, suggest the method outperforms existing approaches like GaLore and BAdam under fixed memory budgets.


Strengths:
	•	The paper addresses a timely and important problem: memory-efficient optimization for large-scale LLM training.
	•	The authors combine adaptive (Adam-like) and sign-based updates, exploring a “split” that preserves a full-rank update signal.
	•	Comprehensive experiments and extensive ablations demonstrate performance gains over some baselines.
	•	Theoretical analysis is provided, aiming to justify the algorithmic design and giving some convergence guarantees.

Decision: Reject