L-SR1: Learned Symmetric-Rank-One Preconditioning

## Abstract

Abstract End-to-end deep learning has achieved impressive results but remains limited by its reliance on large labeled datasets, poor generalization to unseen scenarios, and growing computational demands. In contrast, classical optimization methods are data-efficient and lightweight but often suffer from slow convergence. While learned optimizers offer a promising fusion of both worlds, most focus on first-order methods, leaving learned second-order approaches largely unexplored. We propose a novel learned second-order optimizer that introduces a trainable preconditioning unit to enhance the classical Symmetric-Rank-One (SR1) algorithm. This unit generates data-driven vectors used to construct positive semi-definite rank-one matrices, aligned with the secant constraint via a learned projection. Our method is evaluated through analytic experiments and on the real-world task of Monocular Human Mesh Recovery (HMR), where it outperforms existing learned optimization-based approaches. Featuring a lightweight model and requiring no annotated data or fine-tuning, our approach offers strong generalization and is well-suited for integration into broader optimization-based frameworks.

## 1 Introduction

Figure: (a) Rastrigin function.
Refer to caption: figures/files/trjs_row/trajectories_rast.png

End-to-end deep learning has demonstrated significant power but is constrained by its reliance on large labeled datasets and limited ability to generalize to unseen scenarios. Furthermore, increased model sizes featured in recent works pose a limitation as they demand high compute and memory resources.
In contrast, classical optimization excels in data-scarce settings and features a low memory stamp, but often suffers from long runtime due to its iterative nature. To address this, extensive research has focused on accelerating convergence, with optimization methods broadly categorized into first-order and second-order approaches.

First-order methods, such as Adam kingma2014adam and Nesterov Accelerated Gradient (NAG) nesterov1983method; sutskever2013importance, rely on estimated gradient momentums for parameter updates. Second-order methods, such as Symmetric-Rank-One (SR1) conn1991convergence and Broyden-Fletcher-Goldfarb-Shanno (BFGS) liu1989limited, utilize approximations of the inverse Hessian matrix boyd2004convex. While more computationally intensive, second-order methods typically achieve faster convergence by accurately capturing the underlying structure of the objective function and exploiting dependencies between variables.

Learned optimization has recently emerged as a promising field that leverages deep learning to enhance traditional optimization methods. These approaches incorporate trainable deep neural network (DNN) architectures—such as Multi-Layer Perceptrons (MLPs) andrychowicz2016learning; li2016learning; song2020human, Recurrent Neural Networks (RNNs) andrychowicz2016learning, Transformers gartner2023transformer, and hybrid models metz2020tasks—into optimization frameworks. Once trained on specific objectives, these learned optimizers exhibit significantly faster convergence.
Despite the increasing popularity of learned optimizers, the integration of learnable components with second-order methods still remains largely unexplored.

By accelerating convergence, learned optimizers offer a compelling path to bridging classical optimization techniques with modern deep learning-based approaches in computer vision tasks.

Monocular Human Mesh Recovery (HMR) seeks to estimate a 3D human mesh from a single 2D image—a fundamentally ill-posed problem due to the inherent loss of depth information. Historically, in the absence of large-scale annotated datasets, optimization-based methods dominated the field bogo2016keep; pavlakos2019expressive. However, with the emergence of increasingly comprehensive annotated datasets, these traditional approaches were largely supplanted by deep neural network (DNN)-based methods. These newer methods span both end-to-end regression models and iterative frameworks sun2023trace; shin2024wham; wang2025prompthmr, including learned optimization kolotouros2019learning; song2020human, achieving state-of-the-art performance. Nonetheless, they come with notable trade-offs, including significantly larger model sizes and a continued reliance on vast amounts of annotated training data.

In this work, we introduce Learned-SR1 (L-SR1), a novel learned second-order optimizer that extends the classical SR1 algorithm. Our method incorporates a learnable module that generates data-driven vectors to approximate the Hessian matrix, enabling more informed and efficient updates. To ensure robustness and theoretical soundness, we also propose a learned projection operation that maintains the positive semi-definiteness of the approximation while satisfying the secant condition—an essential principle of Quasi-Newton methods. By building on the SR1 framework, L-SR1 achieves state-of-the-art performance with a notably compact model size.

We evaluate our approach on both analytic benchmark functions and the real-world task of HMR (Fig. [1](https://arxiv.org/html/2508.12270v1#S1.F1)). The results show that L-SR1 converges rapidly and efficiently, while also demonstrating strong generalization. Notably, even when trained in a self-supervised manner and without explicit fine-tuning, L-SR1 outperforms existing optimization-based HMR frameworks. These findings highlight the potential of L-SR1 to be seamlessly integrated into broader optimization-based pipelines, significantly enhancing their performance.

We summarize our key contributions as follows:

- •
We propose Learned-SR1 (L-SR1), a lightweight, self-supervised learned optimizer that integrates a trainable preconditioning unit into the SR1 framework, enabling data-driven curvature estimation without the need for annotated data or supervised meta-training.
- •
We introduce a learned projection mechanism that enforces both the secant condition and positive semi-definiteness, preserving core Quasi-Newton properties within a learned architecture.
- •
We demonstrate that L-SR1 can be seamlessly integrated into optimization-based HMR pipelines, where it consistently outperforms both traditional and learned solvers in terms of convergence and generalization.

## 2 Related Work

##### Second-Order Optimization and Preconditioning

Second-order optimization methods leverage curvature information to accelerate convergence, typically by using the inverse Hessian matrix Bertsekas/99. Since computing and inverting the full Hessian is often impractical, Quasi-Newton methods such as DFP and BFGS Bertsekas/99, LBFGS nocedal1980updating; liu1989limited, and SR1 conn1991convergence; khalfan1993theoretical were introduced to estimate the inverse Hessian iteratively. SR1, in particular, used rank-one updates and demonstrated favorable convergence under mild conditions. These ideas were extended to large-scale problems in deep learning using scalable approximations martens2015optimizing; gupta2018shampoo; yao2021adahessian.

##### Learned Optimization and Model-Based Deep Learning

Learned optimization frameworks integrate trainable modules into iterative solvers, generating adaptive update rules from data andrychowicz2016learning; li2016learning; metz2020tasks; wichrowska2017learned. While earlier works focused on first-order dynamics, more recent methods incorporated richer structures, such as Transformers gartner2023transformer and low-rank attention mechanisms jain2023mnemosyne. Concurrently, model-based deep learning embedded learning into principled algorithmic formulations to preserve interpretability and robustness shlezinger2020viterbinet; revach2022kalmannet; shlezinger2023model.

Within this hybrid space, several methods explored second-order-inspired learned optimizers. Li et al. lilearning and Gärtner et al. gartner2023transformer proposed learned optimizers inspired by Quasi-Newton principles, while Ayad et al. ayad2024qn constructed an unrolled BFGS-like network for CT reconstruction. These works demonstrated the potential of combining learned and second-order methods, but often relied on large models or explicit supervision. Our approach advances this line by introducing a lightweight, self-supervised SR1-inspired preconditioning unit that enforces the secant condition and improves convergence efficiency and generalization.

##### Human Mesh Recovery (HMR)

Human Mesh Recovery (HMR) aims to estimate 3D human meshes from single RGB images, a highly ill-posed problem due to the loss of depth. Early works approached HMR through optimization-based fitting bogo2016keep; pavlakos2019expressive, which, while data-efficient, were slow and sensitive to initialization. With the emergence of large-scale datasets, deep learning methods were introduced, including regression-based approaches shin2024wham; sun2023trace; wang2025prompthmr and iterative refinement techniques, including learned optimization kolotouros2019learning; song2020human; shetty2023pliks. These models achieved impressive performance but depended heavily on annotated data and large architectures. In contrast, our method integrates a learned SR1-inspired optimizer into the HMR process, outperforming learned
optimization-based methods while requiring neither large models nor explicit fine-tuning.

## 3 Theoretical Background and Preliminaries

### 3.1 Learned Optimization

A typical learned optimization framework consists of the following update rule:

$$ $\bm{\mathrm{x}}_{k+1}\leftarrow\bm{\mathrm{x}}_{k}+\varphi_{\Theta}\left(\nabla f(\bm{\mathrm{x}}_{k}),\bm{\mathrm{x}}_{k},\ldots\right),$ (1) $$

where $\varphi_{\Theta}(\cdot)$ is a learnable function parameterized by $\Theta$, which can be conditioned on a variety of features, such as the current iterate and gradient.

Training a learned optimizer, referred to as *meta-training*, involves alternating between *inner* and *outer* iterations. In each outer iteration, the optimizer performs $K$ unrolled inner optimization steps. The *inner* objective values along the optimization trajectory are recorded and used to compute a *meta-loss*, often of the form:

$$ $\mathcal{L}_{\text{meta}}=\sum_{k=1}^{K}f(\bm{\mathrm{x}}_{k}).$ (2) $$

Gradients of this meta-loss with respect to $\Theta$ are then backpropagated through the unrolled computation graph, and the parameters are updated using a *meta-optimizer*.

Figure: Figure 2: Learned-SR1 (L-SR1) iteration block diagram. At each iteration $k$, the Input Encoder $\mathcal{E}$ receives the vectors $\mathbf{x}_{k-1}$, $\mathbf{p}_{k-1}$, $\mathbf{d}_{k-1}$, $\mathbf{g}_{k-1}$, and $\mathbf{q}_{k-1}$, producing a feature vector $\mathbf{f}_{k}$. This is passed to the Vector Generator $\mathcal{P}$, which outputs a new direction vector $\mathbf{v}_{k}$, and to the Learning Rate Generator $\mathcal{G}$, which produces element-wise learning rates $\bm{\alpha}_{k}$ (Sec. [4.1](https://arxiv.org/html/2508.12270v1#S4.SS1))). The updated descent direction $\mathbf{d}_{k}$ is computed as a sum of rank-one terms $\mathbf{v}_{i}\mathbf{v}_{i}^{\top}\mathbf{g}_{k-1}$, using the last $L$ vectors stored in the buffer $\mathcal{B}_{L}$. Finally, the optimization step is performed using $\bm{\alpha}_{k}$ and $\mathbf{d}_{k}$.
Refer to caption: figures/files/learned_sr1.png

### 3.2 Quasi-Newton Methods

Let $f:\mathbb{R}^{n}\rightarrow\mathbb{R}$ be a twice differentiable objective function. The Quasi-Newton (QN) update step is given by

$$ $\bm{\mathrm{x}}_{k+1}\leftarrow\bm{\mathrm{x}}_{k}-\alpha_{k}\bm{\mathrm{B}}_{k}\bm{\mathrm{g}}_{k},$ (3) $$

where $\bm{\mathrm{B}}_{k}$ is a preconditioning matrix approximating the inverse Hessian at $\bm{\mathrm{x}}_{k}$, $\bm{\mathrm{g}}_{k}=\nabla f(\bm{\mathrm{x}}_{k})$ is the gradient, and $\alpha_{k}$ is a step size.

QN methods differ in how they update $\bm{\mathrm{B}}_{k}$, but they all satisfy the *secant constraint*, derived from a first-order Taylor approximation. Defining $\bm{\mathrm{p}}_{k}=\bm{\mathrm{x}}_{k}-\bm{\mathrm{x}}_{k-1}$ and $\bm{\mathrm{q}}_{k}=\bm{\mathrm{g}}_{k}-\bm{\mathrm{g}}_{k-1}$, the secant condition is

$$ $\bm{\mathrm{B}}_{k}\bm{\mathrm{q}}_{k}=\bm{\mathrm{p}}_{k}.$ (4) $$

This condition ensures that the preconditioner $\bm{\mathrm{B}}_{k}$ captures local curvature information. Additionally, $\bm{\mathrm{B}}_{k}$ is typically required to be positive semi-definite to guarantee that the update direction is a descent direction.

## 4 Learned Symmetric-Rank-One (L-SR1)

Figure: Algorithm 1 Learned-SR1 (L-SR1)

L-SR1 is a learned extension of the classical Symmetric Rank-One (SR1) Quasi-Newton method, designed to integrate lightweight trainable modules into a principled second-order optimization framework. The method enhances convergence while maintaining scalability and generalization across problem dimensions.

At its core, SR1 approximates the inverse Hessian matrix using a rank-one update of the form

$$ $\mathbf{B}_{k+1}\leftarrow\mathbf{B}_{k}+\mathbf{u}_{k}\mathbf{v}_{k}^{\top},$ (5) $$

where the vectors $\mathbf{v}_{k}=\mathbf{p}_{k}-\mathbf{B}_{k}\mathbf{q}_{k}$ and
$\mathbf{u}_{k}=\mathbf{v}_{k}/(\mathbf{v}_{k}^{\top}\mathbf{q}_{k})$
are chosen to satisfy the secant constraint presented in Eq. ([4](https://arxiv.org/html/2508.12270v1#S3.E4)).
This ensures that the update captures local curvature information of the objective function.

A significant advantage of the SR1 structure is that it relies solely on outer products of low-dimensional vectors.
This allows for a *limited-memory implementation*, where instead of storing the full matrix $\mathbf{B}_{k}$,
L-SR1 maintains a fixed-size *buffer* $\mathcal{B}_{L}$ containing the most recent $L$ vectors.
These vectors are used to reconstruct $\mathbf{B}_{k}$ implicitly during optimization.
If the buffer exceeds its capacity, the oldest entries are discarded, ensuring memory efficiency in high-dimensional problems.

A central design principle in L-SR1 is *invariance to the problem dimension*.
All learnable components are constructed to operate element-wise,
ensuring that the optimizer generalizes across problem sizes without re-training.

However, a known limitation of SR1 is that its updates do not guarantee positive semi-definiteness of $\mathbf{B}_{k}$,
which can result in non-descent directions and instability.
In the learned optimization realm, a naive fix is to use outer products of the form $\mathbf{v}\mathbf{v}^{\top}$ as was done in gartner2023transformer,
which are always positive semi-definite and symmetric, but such updates fail to satisfy the secant constraint.
Traditional methods like LBFGS address this using more elaborate update strategies.
In contrast, L-SR1 proposes a vector generator unit accompanied by a *novel learned projection* to efficiently maintain both positive definiteness and compliance with the secant constraint.

A summary of the proposed method is given in Alg. [1](https://arxiv.org/html/2508.12270v1#alg1) and a block diagram is in Fig [2](https://arxiv.org/html/2508.12270v1#S3.F2). We now describe the components of the L-SR1 algorithm in detail.
The trainable modules are introduced in Section [4.1](https://arxiv.org/html/2508.12270v1#S4.SS1), and our proposed learned projection mechanism is described in Section [4.2](https://arxiv.org/html/2508.12270v1#S4.SS2).

### 4.1 Learned Components

To enrich SR1 with data-driven flexibility, L-SR1 integrates three neural modules. All modules follow a standard and lightweight multi-layer perceptron (MLP) architecture and operate elementwise over the input dimensions, ensuring compatibility with varying problem sizes. Model architectures are presented in the supplementary material.

##### Input Encoder ℰ \mathcal{E}

The encoder constructs a latent representation of the optimization state. It takes as input
the current point $\mathbf{x}_{k-1}$, previous step $\mathbf{p}_{k-1}$, previous descent direction $\mathbf{d}_{k-1}$, previous gradient $\mathbf{g}_{k-1}$, and previous gradient step $\mathbf{q}_{k-1}$,
which are concatenated into an array of shape $N\times 5$, where $N$ is the problem dimension. The encoder then maps this input to a latent representation $\bm{\mathrm{f}}_{k}\in\mathbb{R}^{N\times M}$, with $M>5$, enabling a richer feature space that informs the subsequent modules.

##### Vector Generator 𝒫 \mathcal{P}

This module produces a single vector $\mathbf{v}_{k}\in\mathbb{R}^{N}$ given $\bm{\mathrm{f}}_{k}$ at each iteration. The outer product $\mathbf{v}_{k}\mathbf{v}_{k}^{\top}$ is then used—together with the learned projection described in Section [4.2](https://arxiv.org/html/2508.12270v1#S4.SS2)—to construct the curvature matrix $\mathbf{B}_{k}$ in a manner analogous to the SR1 update.

##### Learning Rate Generator 𝒢 \mathcal{G}

The learning rate generator takes the latent representation from the encoder $\bm{\mathrm{f}}_{k}$ and outputs a vector $\tilde{\bm{\alpha}}_{k}\in\mathbb{R}^{N}$, interpreted as the logarithm of coordinate-wise learning rates. The final learning rate vector $\bm{\alpha}_{k}$ is computed element-wise using the transformation:

$$ $\bm{\alpha}_{k}=\gamma_{1}\cdot\exp\left(\gamma_{2}\cdot\tilde{\bm{\alpha}}_{k}\right),$ $$

where $\gamma_{1}$ and $\gamma_{2}$ are scalar hyperparameters.

### 4.2 Learned Projection

As discussed earlier, our goal is to construct preconditioning matrices $\mathbf{B}_{k}$ that are both positive semi-definite (PSD) and approximately satisfy the secant equation (Eq. ([4](https://arxiv.org/html/2508.12270v1#S3.E4))). We formalize this requirement through a projection objective that minimizes the violation of the secant condition:

$$ $\mathbf{B}_{k}^{*}=\pi_{+}(\mathbf{B}_{k})=\underset{\mathbf{B}_{k}\in S_{+}}{\text{argmin}}\|\mathbf{p}_{k}-\mathbf{B}_{k}\mathbf{q}_{k}\|_{2}^{2},$ (6) $$

where $S_{+}$ denotes the space of positive semi-definite matrices. This formulation seeks a PSD matrix that best approximates the secant constraint in a least-squares sense.

To ensure scalability and efficient computation, we constrain $\mathbf{B}_{k}$ to take the following structured form:

$$ $\tilde{\mathbf{B}}_{k}=\mathbf{B}_{0}+\sum_{i=1}^{L}\mathbf{v}_{i}\mathbf{v}_{i}^{\top},$ (7) $$

where each vector $\mathbf{v}_{i}\in\mathbb{R}^{n}$ is produced by the vector generator module $\mathcal{P}$ and stored in a fixed-size buffer of length $L$. This construction ensures that $\tilde{\mathbf{B}}_{k}$ remains positive semi-definite as long as $\mathbf{B}_{0}\succ 0$, which we initialize as the identity matrix. The use of outer products is inspired by the classical SR1 update structure and is also consistent with techniques adopted in prior learned optimization works, such as gartner2023transformer, which promote symmetry and positivity.

The projection is thus formulated as the following optimization problem:

$$ $\tilde{\mathbf{B}}_{k}^{*}=\tilde{\pi}_{+}(\tilde{\mathbf{B}}_{k})=\underset{\tilde{\mathbf{B}}_{k}=\mathbf{B}_{0}+\sum_{i=1}^{L}\mathbf{v}_{i}\mathbf{v}_{i}^{\top}}{\text{argmin}}\|\mathbf{p}_{k}-\tilde{\mathbf{B}}_{k}\mathbf{q}_{k}\|_{2}^{2}.$ (8) $$

We define this objective as the *secant penalty* $\mathcal{R}_{\text{sec}}$, which we incorporate into the overall meta-training loss:

$$ $\mathcal{L}_{\text{meta}}=\frac{1}{K}\sum_{k=1}^{K}\left(f(\mathbf{x}_{k})+\lambda_{\text{sec}}\cdot\|\mathbf{p}_{k}-\tilde{\mathbf{B}}_{k}\mathbf{q}_{k}\|_{2}^{2}\right),$ (9) $$

where $\lambda_{\text{sec}}$ is a hyperparameter controlling the importance of satisfying the secant condition, and $K$ is the number of unrolled optimization steps per meta-iteration.

This formulation ensures that the learned preconditioning matrices remain PSD and are trained to satisfy the secant constraint effectively, using only the buffer of learned vectors generated at each step. Notably, this does not add computational overhead during inference.

## 5 Experimentation

Figure: (a) Quadratic objective values.
Refer to caption: figures/files/analytic_curves/agg_vals_no_titles.png

We conduct a series of experiments to evaluate the effectiveness and generalization capabilities of the proposed L-SR1 optimizer. Our evaluation begins with controlled analytic settings: we first isolate the impact of the learned projection mechanism on randomly generated quadratic functions (Section [5.1.1](https://arxiv.org/html/2508.12270v1#S5.SS1.SSS1)), then assess generalization across dimensions using a set of benchmark functions simulationlib (Section Section [5.1.2](https://arxiv.org/html/2508.12270v1#S5.SS1.SSS2)). Finally, we demonstrate L-SR1’s applicability to real-world problems through a 3D human mesh recovery (HMR) task (Section [5.2](https://arxiv.org/html/2508.12270v1#S5.SS2)), showcasing performance in high-dimensional, structured domains. In each experiment, we compare our results against a range of baselines, which are detailed in the corresponding experimental subsections.

##### Implementation Details.

Our method is implemented entirely in PyTorch pytorch(^1^11Code will be made publicly available upon acceptance.).
Following standard learned optimization practices, our training setup consists of inner optimization loops and outer meta-iterations. Using PyTorch’s autograd framework, we compute gradients of the inner objective with respect to the optimization variables during each unrolled step, and gradients of the meta-loss (Eq. ([9](https://arxiv.org/html/2508.12270v1#S4.E9))) with respect to the optimizer’s parameters during each meta-iteration.
We use the AdamW loshchilov2017decoupled optimizer for meta-training, with a fixed learning rate of $10^{-4}$, momentum parameters $\beta_{1}=0.9$, $\beta_{2}=0.999$, and weight decay coefficient $\lambda=0.01$.
Unless otherwise stated, meta-training is run for 10K iterations and takes approximately 15 hours on a single NVIDIA GeForce RTX 3090 GPU.
Compute runtime and memory analysis is given in the supplementary material.

### 5.1 Analytic Experiments

#### 5.1.1 Quadratic Functions

We first evaluate our method on randomly generated quadratic functions of the form

$$ $f(\mathbf{x})=\frac{1}{2}\mathbf{x}^{\top}\mathbf{H}\mathbf{x}+\mathbf{b}^{\top}\mathbf{x},$ (10) $$

where $\mathbf{H}\in\mathbb{R}^{N\times N}$ is a random positive semi-definite matrix and $\mathbf{b}\in\mathbb{R}^{N}$ is a random vector.
A fixed validation set of 32 such functions and corresponding initial points $\mathbf{x}_{0}$ is used throughout meta-training.
At each meta-iteration, random training batches of size 128 are generated, while validation is performed on the fixed set.
Both training and validation are performed on functions with $N=2$.
To assess generalization across dimensions, a test set of 32 new functions and initials with $N=10$ is used.
Training is conducted with buffer size $L=8$, while testing is done with varying buffer sizes.
We compare our L-SR1 optimizer, with and without the learned projection mechanism, to LBFGS nocedal1980updating, which is explicitly suited to quadratic functions and serves as a reference.
Further implementation details are provided in the supplementary material.

##### Results

Figure [3(a)](https://arxiv.org/html/2508.12270v1#S5.F3.sf1) presents the average test loss for the first 20 iterations. As expected, L-BFGS, being data-independent and tailored to quadratic problems, achieves the fastest convergence across all tested buffer sizes. Our L-SR1 with the learned projection consistently outperforms its non-projected variant, highlighting the effectiveness of enforcing the secant constraint. Notably, our method retains strong performance even with reduced buffer sizes, similar to L-BFGS.

Figure [3(b)](https://arxiv.org/html/2508.12270v1#S5.F3.sf2) shows the average cosine similarity between the descent directions and the corresponding Newton directions on the test set. The version with the projection exhibits steadily increasing similarity, indicating its ability to learn curvature-aware updates. In contrast, the non-projected variant shows less consistent alignment, further underscoring the benefit of our projection mechanism.

#### 5.1.2 Performance Profiles

We compare our learned optimizer against several baselines using performance profiles, a standard evaluation method for optimization algorithms dolan2002benchmarking; sergeyev2015deterministic; beiranvand2017best; gartner2023transformer. Let $P$ represent the set of problems and $S$ the set of solvers. For each solver $s$ and problem $p$, the performance measure $m_{p,s}$ is defined as:
$m_{p,s}=\frac{\|\hat{\mathbf{x}}_{p,s}-\mathbf{x}^{\ast}\|_{2}}{\|\mathbf{x}_{w}-\mathbf{x}^{\ast}\|_{2}},$
where $\hat{\mathbf{x}}_{p,s}$ is the solution found by solver $s$ on problem $p$ after $K$ steps, $\mathbf{x}_{w}$ is the worst solution among solvers, and $\mathbf{x}^{\ast}$ is the global optimum. The performance ratio for each solver is:
$r_{p,s}=\frac{m_{p,s}}{\min\left(m_{p,s}\ :\ s\in S\right)},$
with the best solver achieving $r_{p,s}=1$.

The performance profile for solver $s$ is then defined as:

$$ $\rho_{s}(\tau)=\frac{1}{|P|}\text{size}\left(\{p\in P\ :\ r_{p,s}\leq\tau\}\right).$ (11) $$

This measures the proportion of problems where the performance ratio of solver $s$ is within a factor $\tau$ of the best.

We meta-train our model on random quadratic functions and on Rosenbrock and Rastrigin functions with $N=100$. The test set includes 30 benchmark problems: quadratics with condition numbers 1, 100, and 1000, and Rosenbrock and Rastrigin functions with dimensions ranging from 50 to 1000.
We compare L-SR1 (with and without the learned projection) to L-BFGS nocedal1980updating, Adam kingma2014adam, and AdaHessian yao2021adahessian.
Figure [3(c)](https://arxiv.org/html/2508.12270v1#S5.F3.sf3) shows that our method achieves the highest performance profile, demonstrating strong overall effectiveness.

### 5.2 Monocular Human Mesh Recovery (HMR)

We integrate our lightweight L-SR1 optimizer into the learned optimization based HMR framework of song2020human, which consists of trainable initialization and update modules inspired by gradient descent (LGD).
Adding self-supervision loss terms during training replaced the need for exhaustive and highly engineers loss terms, as in bogo2016keep; pavlakos2019expressive.
By replacing their update module with our method, we achieve faster convergence and improved accuracy. Notably, our model delivers competitive results without explicit fine-tuning and with a significantly smaller model size.

##### Training and Evaluation

Our model follows the training pipeline of song2020human, using the AMASS dataset AMASS(^2^22The AMASS AMASS dataset an aggregation of the following datasets AMASS_ACCAD; AMASS_BMLhandball; AMASS_BMLmovi; AMASS_BMLrub; AMASS_CMU; AMASS_DanceDB; AMASS_DFaust; AMASS_EyesJapanDataset; AMASS_GRAB; AMASS_GRAB-2; AMASS_HDM05; AMASS_HUMAN4D; AMASS_HumanEva; AMASS_KIT-CNRS-EKUT-WEIZMANN; AMASS_KIT-CNRS-EKUT-WEIZMANN-2; AMASS_KIT-CNRS-EKUT-WEIZMANN-3; AMASS_MoSh; AMASS_MOYO; AMASS_PosePrior; AMASS_SFU; AMASS_SOMA; AMASS_TCDHands; AMASS_TotalCapture; AMASS_WheelPoser.) to predict shape and pose parameters $(\bm{\mathrm{\beta}}_{\text{gt}},\bm{\mathrm{\theta}}_{\text{gt}})$.
The SMPL loper2023smpl body model(^3^33Although more sophisticated and accurate body models exist, such as pavlakos2019expressive; STAR:2020, SMPL loper2023smpl was chosen for its widespread availability and ease of integration.) is used to reconstruct 3D meshes from these parameters, and the 2D joint locations $\bm{\mathrm{x}}_{\text{gt}}$ are obtained by projection and used as inputs. At each inner-iteration $k$, the optimizer estimates parameters $(\bm{\mathrm{\beta}}_{k},\bm{\mathrm{\theta}}_{k})$, which are used to generate predicted 3D and 2D joints, $\bm{\mathrm{X}}_{k}$ and $\bm{\mathrm{x}}_{k}$, respectively. The reconstruction loss function, defined as

$$ $f_{\text{rec}}\left(\bm{\mathrm{x}}_{k}\right)=\left\|\bm{\mathrm{w}}\odot\left(\bm{\mathrm{x}}_{k}-\bm{\mathrm{x}}_{\text{gt}}\right)\right\|_{1},$ (12) $$

serves as our inner objective, where $\bm{\mathrm{w}}$ are confidence weights and $\odot$ stands for element-wise multiplication.

Incorporating self-supervision as in song2020human and our proposed secant constraint, our total meta-loss is:

$$ $\mathcal{L}_{\text{meta}}=\sum_{k=1}^{K}\left(\lambda_{\text{2D}}f\left(\bm{\mathrm{x}}_{k}\right)+\lambda_{\text{self}}\|\Theta_{k}-\Theta_{\text{gt}}\|_{1}\right)+\lambda_{\text{sec}}\mathcal{R}_{\text{sec}},$ (13) $$

where $\Theta_{k}=\left\{\bm{\mathrm{X}}_{k},\bm{\mathrm{\theta}}_{k},\bm{\mathrm{\beta}}_{k}\right\}$ and $\lambda_{\text{2D}}$, $\lambda_{\text{self}}$, and $\lambda_{\text{sec}}$ are hyperparameters. Further implementation details are available in the supplementary material.

We evaluate our method on the challenging 3DPW dataset vonMarcard2018, which features complex, in-the-wild poses, and report PA-MPJPE on the test set.
Following the evaluation protocol of song2020human, we use the 2D keypoints included in the dataset (from openpose cao2019openpose).

Figure: (a) Reprojection error curves.
Refer to caption: figures/files/hmr_reprojections_no_titles.png

Figure: Table 1: Optimization evaluation on 3DPW. Official PA-MPJPE of optimizaion based frameworks are given. For learned optimizers, we also report the number of steps (Steps) to reach the lowest error and model size (# Params). For our method, the value in brackets shows the error after 4 steps, for direct comparison with LGD song2020human.
Refer to caption: figures/files/hmr_qualitative.png

##### Results

Table [1](https://arxiv.org/html/2508.12270v1#S5.T1) summarizes reported errors and required inner iterations for learned optimization methods. Our method outperforms LGD in accuracy while featuring a smaller model size.
Qualitative examples are given in Fig. [5](https://arxiv.org/html/2508.12270v1#S5.F5). More examples are available in the supplementary material.

## 6 Conclusions

We introduced a novel trainable second-order preconditioning unit that enhances the SR1 algorithm through a projection operation, ensuring positive definite preconditioning matrices that satisfy the secant constraint.
Our method outperforms existing optimizers in benchmark tasks, achieving the highest performance profile and converging to the global minimum faster, even in challenging problems.
In Human Mesh Recovery (HMR), our approach improves convergence speed and accuracy, achieving competitive results with a smaller model size and no explicit fine-tuning.

We believe our method can accelerate gradient-based optimization frameworks, reducing runtime by converging in fewer iterations.

## References

- (1)
Advanced Computing Center for the Arts and Design.
ACCAD MoCap Dataset.
- (2)
Ijaz Akhter and Michael J. Black.
Pose-conditioned joint angle limits for 3D human pose reconstruction.
In IEEE Conf. on Computer Vision and Pattern Recognition (CVPR) 2015, June 2015.
- (3)
Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas.
Learning to learn by gradient descent by gradient descent.
Advances in neural information processing systems, 29, 2016.
- (4)
Andreas Aristidou, Ariel Shamir, and Yiorgos Chrysanthou.
Digital dance ethnography: Organizing large dance collections.
J. Comput. Cult. Herit., 12(4), Nov. 2019.
- (5)
Ishak Ayad, Nicolas Larue, and Maï K Nguyen.
Qn-mixer: A quasi-newton mlp-mixer model for sparse-view ct reconstruction.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 25317–25326, 2024.
- (6)
Vahid Beiranvand, Warren Hare, and Yves Lucet.
Best practices for comparing optimization algorithms.
Optimization and Engineering, 18:815–848, 2017.
- (7)
D.P. Bertsekas.
Nonlinear Programming.
Athena Scientific, 1999.
- (8)
Federica Bogo, Angjoo Kanazawa, Christoph Lassner, Peter Gehler, Javier Romero, and Michael J Black.
Keep it smpl: Automatic estimation of 3d human pose and shape from a single image.
In Computer Vision–ECCV 2016: 14th European Conference, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part V 14, pages 561–578. Springer, 2016.
- (9)
Federica Bogo, Javier Romero, Gerard Pons-Moll, and Michael J. Black.
Dynamic FAUST: Registering human bodies in motion.
In IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), July 2017.
- (10)
Stephen Boyd, Stephen P Boyd, and Lieven Vandenberghe.
Convex optimization.
Cambridge university press, 2004.
- (11)
Samarth Brahmbhatt, Cusuh Ham, Charles C. Kemp, and James Hays.
ContactDB: Analyzing and predicting grasp contact via thermal imaging.
In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
- (12)
Zhe Cao, Gines Hidalgo, Tomas Simon, Shih-En Wei, and Yaser Sheikh.
Openpose: Realtime multi-person 2d pose estimation using part affinity fields.
IEEE transactions on pattern analysis and machine intelligence, 43(1):172–186, 2019.
- (13)
Carnegie Mellon University.
CMU MoCap Dataset.
- (14)
Anargyros Chatzitofis, Leonidas Saroglou, Prodromos Boutis, Petros Drakoulis, Nikolaos Zioulis, Shishir Subramanyam, Bart Kevelham, Caecilia Charbonnier, Pablo Cesar, Dimitrios Zarpalas, et al.
Human4d: A human-centric multimodal dataset for motions and immersive media.
IEEE Access, 8:176241–176262, 2020.
- (15)
Andrew R Conn, Nicholas IM Gould, and Ph L Toint.
Convergence of quasi-newton matrices generated by the symmetric rank one update.
Mathematical programming, 50(1):177–195, 1991.
- (16)
Elizabeth D Dolan and Jorge J Moré.
Benchmarking optimization software with performance profiles.
Mathematical programming, 91:201–213, 2002.
- (17)
Erik Gärtner, Luke Metz, Mykhaylo Andriluka, C Daniel Freeman, and Cristian Sminchisescu.
Transformer-based learned optimization.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11970–11979, 2023.
- (18)
Nima Ghorbani and Michael J. Black.
SOMA: Solving optical marker-based mocap automatically.
In Proc. International Conference on Computer Vision (ICCV), pages 11117–11126, Oct. 2021.
- (19)
Saeed Ghorbani, Kimia Mahdaviani, Anne Thaler, Konrad Kording, Douglas James Cook, Gunnar Blohm, and Nikolaus F. Troje.
MoVi: A large multipurpose motion and video dataset.
arXiv preprint arXiv: 2003.01888, 2020.
- (20)
Vineet Gupta, Tomer Koren, and Yoram Singer.
Shampoo: Preconditioned stochastic tensor optimization.
In International Conference on Machine Learning, pages 1842–1850. PMLR, 2018.
- (21)
Fabian Helm, Nikolaus Troje, Mathias Reiser, and JÃ¶rn Munzert.
Bewegungsanalyse getÃ¤uschter und nicht-getÃ¤uschter 7m-wÃ¼rfe im handball.
01 2015.
- (22)
Ludovic Hoyet, Kenneth Ryall, Rachel McDonnell, and Carol O’Sullivan.
Sleight of hand: Perception of finger motion from reduced marker sets.
In Proceedings of the ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, pages 79–86, 2012.
- (23)
Deepali Jain, Krzysztof M Choromanski, Kumar Avinava Dubey, Sumeet Singh, Vikas Sindhwani, Tingnan Zhang, and Jie Tan.
Mnemosyne: Learning to train transformers with transformers.
Advances in Neural Information Processing Systems, 36:77331–77358, 2023.
- (24)
H Fayez Khalfan, Richard H Byrd, and Robert B Schnabel.
A theoretical and experimental study of the symmetric rank-one update.
SIAM Journal on Optimization, 3(1):1–24, 1993.
- (25)
Diederik P Kingma and Jimmy Ba.
Adam: A method for stochastic optimization.
arXiv preprint arXiv:1412.6980, 2014.
- (26)
Nikos Kolotouros, Georgios Pavlakos, Michael J Black, and Kostas Daniilidis.
Learning to reconstruct 3d human pose and shape via model-fitting in the loop.
In Proceedings of the IEEE/CVF international conference on computer vision, pages 2252–2261, 2019.
- (27)
Franziska Krebs, Andre Meixner, Isabel Patzer, and Tamim Asfour.
The KIT bimanual manipulation dataset.
In IEEE/RAS International Conference on Humanoid Robots (Humanoids), pages 499–506, 2021.
- (28)
Ke Li and Jitendra Malik.
Learning to optimize.
arXiv preprint arXiv:1606.01885, 2016.
- (29)
Maojia Li, Jialin Liu, and Wotao Yin.
Learning to combine quasi-newton methods.
- (30)
Yunzhi Li, Vimal Mollyn, Kuang Yuan, and Patrick Carrington.
Wheelposer: Sparse-imu based body pose estimation for wheelchair users.
In Proceedings of the 26th International ACM SIGACCESS Conference on Computers and Accessibility, pages 1–17, 2024.
- (31)
DC Liu and J Nocedal.
On the limited memory method for large scale optimization: Mathematical programming b.
1989.
- (32)
Matthew Loper, Naureen Mahmood, Javier Romero, Gerard Pons-Moll, and Michael J Black.
Smpl: A skinned multi-person linear model.
In Seminal Graphics Papers: Pushing the Boundaries, Volume 2, pages 851–866. 2023.
- (33)
Matthew M. Loper, Naureen Mahmood, and Michael J. Black.
MoSh: Motion and shape capture from sparse markers.
ACM Transactions on Graphics, (Proc. SIGGRAPH Asia), 33(6):220:1–220:13, Nov. 2014.
- (34)
Ilya Loshchilov and Frank Hutter.
Decoupled weight decay regularization.
arXiv preprint arXiv:1711.05101, 2017.
- (35)
Eyes JAPAN Co. Ltd.
Eyes Japan MoCap Dataset.
- (36)
Naureen Mahmood, Nima Ghorbani, Nikolaus F. Troje, Gerard Pons-Moll, and Michael J. Black.
AMASS: Archive of motion capture as surface shapes.
In International Conference on Computer Vision, pages 5442–5451, Oct. 2019.
- (37)
Christian Mandery, Ömer Terlemez, Martin Do, Nikolaus Vahrenkamp, and Tamim Asfour.
The KIT whole-body human motion database.
In International Conference on Advanced Robotics (ICAR), pages 329–336, 2015.
- (38)
Christian Mandery, Ömer Terlemez, Martin Do, Nikolaus Vahrenkamp, and Tamim Asfour.
Unifying representations and large-scale whole-body motion databases for studying human motion.
IEEE Transactions on Robotics, 32(4):796–809, 2016.
- (39)
James Martens and Roger Grosse.
Optimizing neural networks with kronecker-factored approximate curvature.
In International conference on machine learning, pages 2408–2417. PMLR, 2015.
- (40)
Luke Metz, Niru Maheswaranathan, C Daniel Freeman, Ben Poole, and Jascha Sohl-Dickstein.
Tasks, stability, architecture, and compute: Training more effective learned optimizers, and using them to train themselves.
arXiv preprint arXiv:2009.11243, 2020.
- (41)
M. Müller, T. Röder, M. Clausen, B. Eberhardt, B. Krüger, and A. Weber.
Documentation mocap database hdm05.
Technical Report CG-2007-2, Universität Bonn, June 2007.
- (42)
Yurii Evgen’evich Nesterov.
A method of solving a convex programming problem with convergence rate o$\backslash$bigl(kˆ2$\backslash$bigr).
In Doklady Akademii Nauk, volume 269, pages 543–547. Russian Academy of Sciences, 1983.
- (43)
Jorge Nocedal.
Updating quasi-newton matrices with limited storage.
Mathematics of computation, 35(151):773–782, 1980.
- (44)
Ahmed A A Osman, Timo Bolkart, and Michael J. Black.
STAR: A sparse trained articulated human body regressor.
In European Conference on Computer Vision (ECCV), pages 598–613, 2020.
- (45)
Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala.
Pytorch: An imperative style, high-performance deep learning library.
In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019.
- (46)
Georgios Pavlakos, Vasileios Choutas, Nima Ghorbani, Timo Bolkart, Ahmed AA Osman, Dimitrios Tzionas, and Michael J Black.
Expressive body capture: 3d hands, face, and body from a single image.
In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 10975–10985, 2019.
- (47)
Guy Revach, Nir Shlezinger, Xiaoyong Ni, Adria Lopez Escoriza, Ruud JG Van Sloun, and Yonina C Eldar.
Kalmannet: Neural network aided kalman filtering for partially known dynamics.
IEEE Transactions on Signal Processing, 70:1532–1547, 2022.
- (48)
Yaroslav D Sergeyev and Dmitri E Kvasov.
A deterministic global optimization using smooth diagonal auxiliary functions.
Communications in Nonlinear Science and Numerical Simulation, 21(1-3):99–111, 2015.
- (49)
Karthik Shetty, Annette Birkhold, Srikrishna Jaganathan, Norbert Strobel, Markus Kowarschik, Andreas Maier, and Bernhard Egger.
Pliks: A pseudo-linear inverse kinematic solver for 3d human body estimation.
In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 574–584, 2023.
- (50)
Soyong Shin, Juyong Kim, Eni Halilaj, and Michael J Black.
Wham: Reconstructing world-grounded humans with accurate 3d motion.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2070–2080, 2024.
- (51)
Nir Shlezinger, Nariman Farsad, Yonina C Eldar, and Andrea J Goldsmith.
Viterbinet: A deep learning based viterbi algorithm for symbol detection.
IEEE Transactions on Wireless Communications, 19(5):3319–3331, 2020.
- (52)
Nir Shlezinger, Jay Whang, Yonina C Eldar, and Alexandros G Dimakis.
Model-based deep learning.
Proceedings of the IEEE, 2023.
- (53)
L. Sigal, A. Balan, and M. J. Black.
HumanEva: Synchronized video and motion capture dataset and baseline algorithm for evaluation of articulated human motion.
International Journal of Computer Vision, 87(1):4–27, Mar. 2010.
- (54)
Jie Song, Xu Chen, and Otmar Hilliges.
Human body model fitting by learned gradient descent.
In European Conference on Computer Vision, pages 744–760. Springer, 2020.
- (55)
Yu Sun, Qian Bao, Wu Liu, Tao Mei, and Michael J Black.
Trace: 5d temporal regression of avatars with dynamic cameras in 3d environments.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8856–8866, 2023.
- (56)
S. Surjanovic and D. Bingham.
Virtual library of simulation experiments: Test functions and datasets.
Retrieved May 5, 2024, from [http://www.sfu.ca/˜ssurjano](http://www.sfu.ca/~ssurjano).
- (57)
Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton.
On the importance of initialization and momentum in deep learning.
In International conference on machine learning, pages 1139–1147. PMLR, 2013.
- (58)
Omid Taheri, Nima Ghorbani, Michael J. Black, and Dimitrios Tzionas.
GRAB: A dataset of whole-body human grasping of objects.
In European Conference on Computer Vision (ECCV), 2020.
- (59)
Shashank Tripathi, Lea Müller, Chun-Hao P. Huang, Taheri Omid, Michael J. Black, and Dimitrios Tzionas.
3D human pose estimation via intuitive physics.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2023.
- (60)
Nikolaus F. Troje.
Decomposing biological motion: A framework for analysis and synthesis of human gait patterns.
Journal of Vision, 2(5):2–2, Sept. 2002.
- (61)
Matt Trumble, Andrew Gilbert, Charles Malleson, Adrian Hilton, and John Collomosse.
Total Capture: 3d human pose estimation fusing video and inertial sensors.
In 2017 British Machine Vision Conference (BMVC), 2017.
- (62)
Simon Fraser University and National University of Singapore.
SFU Motion Capture Database.
- (63)
Timo von Marcard, Roberto Henschel, Michael Black, Bodo Rosenhahn, and Gerard Pons-Moll.
Recovering accurate 3d human pose in the wild using imus and a moving camera.
In European Conference on Computer Vision (ECCV), sep 2018.
- (64)
Yufu Wang, Yu Sun, Priyanka Patel, Kostas Daniilidis, Michael J Black, and Muhammed Kocabas.
Prompthmr: Promptable human mesh recovery.
arXiv preprint arXiv:2504.06397, 2025.
- (65)
Olga Wichrowska, Niru Maheswaranathan, Matthew W Hoffman, Sergio Gomez Colmenarejo, Misha Denil, Nando Freitas, and Jascha Sohl-Dickstein.
Learned optimizers that scale and generalize.
In International conference on machine learning, pages 3751–3760. PMLR, 2017.
- (66)
Zhewei Yao, Amir Gholami, Sheng Shen, Mustafa Mustafa, Kurt Keutzer, and Michael Mahoney.
Adahessian: An adaptive second order optimizer for machine learning.
In proceedings of the AAAI conference on artificial intelligence, volume 35, pages 10665–10673.

## Appendix A Computational Analysis

Figure: Figure 6: Computational effort during inference. Measurements were collected on a single NVIDIA RTX 3090 GPU and correspond to the mean runtime per inner inference iteration and peak memory with a batch size of 32.
Refer to caption: figures/files/runtimes_eval.png

Figure: Figure 7: Computational effort during meta-training. Measurements were collected on a single NVIDIA RTX 3090 GPU and correspond to the mean runtime per inner inference iteration and peak memory usage with a batch size of 4.
Refer to caption: figures/files/runtimes_train.png

**Table 2: HMR runtime and memory comparison. Measurements were collected on a single NVIDIA RTX 3090 GPU and correspond to the mean runtime per inner inference iteration and peak memory usage, using a batch size of 256.**
| Method | Runtime (ms) | Memory (GiB) |
| --- | --- | --- |
| LGD song2020human | 166 | 17.81 |
| L-SR1 | 91 | 14.60 |

## Appendix B Ablations

**Table 3: Varying hidden dimension and encoder inputs. Quadratic validation set errors for different configurations of the hidden dimension and selected inputs to the encoder.**
| Hidden dim. | Encoder Inputs |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| $d_{\text{hidden}}$ | $\bm{\mathrm{x}}_{k-1}$ | $\bm{\mathrm{p}}_{k-1}$ | $\bm{\mathrm{d}}_{k-1}$ | $\bm{\mathrm{g}}_{k-1}$ | $\bm{\mathrm{q}}_{k-1}$ | Valid. loss |
| 128 | ✓ | ✗ | ✗ | ✓ | ✗ | -2.09 $\pm$ 1.85 |
| 128 | ✓ | ✗ | ✓ | ✓ | ✗ | -2.16 $\pm$ 1.95 |
| 128 | ✓ | ✓ | ✗ | ✓ | ✓ | -2.51 $\pm$ 2.64 |
| 64 | ✓ | ✓ | ✓ | ✓ | ✓ | -1.90 $\pm$ 1.76 |
| 128 | ✓ | ✓ | ✓ | ✓ | ✓ | -2.56 $\pm$ 2.80 |

We conducted a series of ablation studies on our model components. All experiments were carried out on the validation set, which comprises 32 quadratic functions as detailed in Appendix [C.2.1](https://arxiv.org/html/2508.12270v1#A3.SS2.SSS1). Table [3](https://arxiv.org/html/2508.12270v1#A2.T3) summarizes the results. We evaluated the impact of varying the hidden dimension as well as different combinations of inputs to the encoder. The selected configuration is highlighted in bold.

## Appendix C Implementation Details

### C.1 L-SR1 Modules Architectures

Our proposed L-SR1 model comprises three learnable modules: an Input Encoder $\mathcal{E}$, a Vector Generator $\mathcal{P}$, and a Learning Rate (LR) Generator $\mathcal{G}$. All modules operate element-wise and share a common MLP-based architecture, detailed in Tables [4](https://arxiv.org/html/2508.12270v1#A3.T4) and [5](https://arxiv.org/html/2508.12270v1#A3.T5).

We set $d_{\text{hidden}}=128$ in all experiments. As described in Section 4.1 and justified in Appendix  [B](https://arxiv.org/html/2508.12270v1#A2), the Input Encoder uses $d_{\text{in}}=5$ and $d_{\text{out}}=d_{\text{hidden}}$, while both the Vector and LR Generators use $d_{\text{in}}=d_{\text{hidden}}$ and $d_{\text{out}}=1$.

**Table 4: MLP architecture**
| Layer | Type | Parameters |
| --- | --- | --- |
| fc1 | Linear | Input: $d_{\text{in}}$, Output: $d_{\text{hidden}}$ |
| bn1 | BatchNorm | Features: $d_{\text{hidden}}$ |
| prelu | PReLU | – |
| do1 | Dropout | – |
| MLP1 | Basic Block | Features: $d_{\text{hidden}}$ |
| MLP2 | Basic Block | Features: $d_{\text{hidden}}$ |
| fc2 | Linear | Input: $d_{\text{hidden}}$, Output: $d_{\text{out}}$ |

**Table 5: Basic Block Architecture**
| Layer | Type | Parameters |
| --- | --- | --- |
| fc1 | Linear | Input: $d_{\text{in}}$, Output: $d_{\text{hidden}}$ |
| bn1 | BatchNorm | Features: $d_{\text{hidden}}$ |
| prelu | PReLU | – |
| do1 | Dropout | – |
| fc2 | Linear | Input: $d_{\text{hidden}}$, Output: $d_{\text{hidden}}$ |
| bn2 | BatchNorm | Features: $d_{\text{hidden}}$ |
| do2 | Dropout | – |

### C.2 Experimental setup

#### C.2.1 Quadratic Functions

##### Data

We generate random quadratic functions of the form

$$ $f(\mathbf{x})=\frac{1}{2}\mathbf{x}^{\top}\mathbf{H}\mathbf{x}+\mathbf{b}^{\top}\mathbf{x},$ (14) $$

where $\mathbf{H}\in\mathbb{R}^{N\times N}$ is a positive semi-definite matrix and $\mathbf{b}\in\mathbb{R}^{N}$ is a random vector.

To construct $\mathbf{H}$, we draw a matrix $\mathbf{A}\in\mathbb{R}^{N\times N}$ from a standard normal distribution and define

$$ $\mathbf{H}=\mathbf{A}^{\top}\mathbf{A},$ (15) $$

ensuring positive semi-definiteness. We compute the condition number of each $\mathbf{H}$ and discard those exceeding 1000. This process is repeated until full validation and test bathces are acquired. Each matrix is then normalized to have unit Frobenius norm.
Independently, $\mathbf{b}$ is sampled from a standard normal distribution and normalized to have unit Euclidean norm.

During training batch generation, we relax the condition number constraint and accept all generated matrices, regardless of their conditioning. We use $N=2$ for both training and validation, and $N=10$ for testing. Training batches consist of 128 samples, while validation and test sets each contain 32 samples.

##### Hyperparameters

We use the AdamW optimizer loshchilov2017decoupled for meta-training, with a fixed learning rate of $10^{-4}$, momentum parameters $\beta_{1}=0.9$ and $\beta_{2}=0.999$, and a weight decay coefficient of $\lambda=0.01$. Training is conducted for 10,000 meta-iterations.

We set the buffer size to $L=8$ and the number of unrolled iterations to $K=16$. The Learning Rate Generator is configured with scaling parameters $\gamma_{1}=0.4$ and $\gamma=0.001$. A secant constraint is applied with a weighting factor of $\lambda_{\text{sec}}=100$. The learning rates for non-trainable optimizers were selected through hyperparameter tuning.

#### C.2.2 Performance Profiles

##### Data

The quadratic functions used in this experiment are a subset of those defined in Eq. [14](https://arxiv.org/html/2508.12270v1#A3.E14), where $\mathbf{b}=\mathbf{0}$ and $\mathbf{H}$ is constrained to be diagonal. Our objective set comprises four such quadratic functions with condition numbers 1, 100, 1000, and 10000, along with the Rosenbrock and Rastrigin functions simulationlib. Each function is evaluated at input dimensions $N=50,100,250,500$, and $1000$, yielding a total of 30 distinct optimization problems.

The solver set includes our proposed L-SR1 optimizer, both with and without the learned projection, along with three non-trainable baselines: L-BFGS nocedal1980updating, Adam kingma2014adam, and AdaHessian yao2021adahessian, totaling six solvers. The learning rates for non-trainable optimizers were selected through hyperparameter tuning.

Each trainable optimizer is meta-trained on three distinct tasks: a randomly generated quadratic function (as defined in Eq. [14](https://arxiv.org/html/2508.12270v1#A3.E14)), the Rosenbrock function, and the Rastrigin function. For each task, a validation set of 8 fixed initial points is created and remains unchanged throughout meta-training. During each meta-iteration, a new training batch of 8 initial points is generated. Both training and validation are performed with $N=100$.

##### Hyperparameters

**Table 6: Hyperparameters used in Performance profiles**
| Parameter | Quadratics | Rosenbrock | Rastrigin |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
|  | Train | Test | Train | Test | Train | Test |
| LR gen. param. $\gamma_{1}$ | 0.1 | 0.1 | 0.1 | 0.1 | 0.1 | 0.1 |
| LR gen. param. $\gamma_{2}$ | 0.001 | 0.001 | 0.001 | 0.001 | 0.001 | 0.001 |
| Buffer size $L$ | 16 | 64 | 32 | 64 | 32 | 64 |
| Unrolled iterations $K$ | 32 | - | 64 | - | 64 | - |
| Secant loss weight $\lambda_{\text{sec}}$ | 10 | - | 1 | - | 1 | - |

We use the AdamW optimizer loshchilov2017decoupled for meta-training, with a fixed learning rate of $10^{-4}$, momentum parameters $\beta_{1}=0.9$ and $\beta_{2}=0.999$, and a weight decay coefficient of $\lambda=0.01$. Training is conducted for 10,000 meta-iterations. Used hyperparameters are summarized in Table [6](https://arxiv.org/html/2508.12270v1#A3.T6).

#### C.2.3 Monocular Human Mesh Recovery (HMR)

##### Data

We follow the training and evaluation protocol of song2020human. Training is performed on the AMASS dataset AMASS, which comprises SMPL body models loper2023smpl parameterized by $(\bm{\beta}_{\text{gt}},\bm{\theta}_{\text{gt}})$. At each training iteration, a batch of 2D joints is generated by projecting the corresponding 3D joints onto a randomly sampled camera view.

Validation and testing are conducted on the 3DPW dataset vonMarcard2018 using the same protocol as song2020human, utilizing the provided 2D joint detections obtained via OpenPose cao2019openpose. During training, we evaluate our model on the official 3DPW validation set and retain the checkpoint that achieves the best validation performance. The results reported in the paper are obtained by evaluating this best-performing model on the official 3DPW test set. Meta-training and validation graphs are given in Fig. [8](https://arxiv.org/html/2508.12270v1#A3.F8).

##### Hyperparameters

We meta-train for 400K iterations using the AdamW optimizer loshchilov2017decoupled, with an initial learning rate of $10^{-3}$, which is decayed by a factor of $\gamma=0.8$ every 20K iterations. The momentum parameters are set to $\beta_{1}=0.9$ and $\beta_{2}=0.999$, and the weight decay coefficient is $\lambda=0.01$.

We configure the meta-optimization process with a buffer size of $L=4$ and $K=8$ unrolled iterations. The Learning Rate Generator is parameterized with scaling factors $\gamma_{1}=0.1$ and $\gamma=0.001$. The secant constraint is weighted with $\lambda_{\text{sec}}=1$.

Figure: (a) HMR meta-loss on AMASS AMASS.
Refer to caption: figures/files/hmr_meta_training.png

## Appendix D Limitations

Despite its strong performance, our learned second-order optimizer has certain limitations—most notably, a relatively high runtime compared to first-order methods such as Adam kingma2014adam (see Appendix [A](https://arxiv.org/html/2508.12270v1#A1)). However, in optimization settings where loss evaluation and gradient computation are the primary computational bottlenecks, our method can be effectively integrated to reduce the number of iterations required, thereby offering overall performance gains, as demonstrated in this paper.

## Appendix E HMR Qualitative Results

Figure: Figure 9: Qualitative comparison of L-SR1 (ours) and LGD HMR results. Meshes optimized with L-SR1 (Ours) are shown in white, while those from LGD song2020human are shown in pink. Regions of interest are highlighted with red circles.
Refer to caption: figures/files/sup_hmr_2.png

## Appendix F Theoretical Background

### F.1 Quasi-Newton Approach

Consider the Newton Method (NM), which utilizes the full Hessian matrix for preconditioning via directional adjustments. The NM minimization direction is defined as

$$ $\bm{\mathrm{d}}_{\text{NM}}=-\bm{\mathrm{H}}^{-1}(\bm{\mathrm{x}}_{k})\nabla f(\bm{\mathrm{x}}_{k}),$ (16) $$

where $\bm{\mathrm{H}}^{-1}(\bm{\mathrm{x}}_{k})$ represents the inverse Hessian matrix evaluated at $\bm{\mathrm{x}}_{k}$. Notably, when $f$ is quadratic, NM theoretically converges in a single iteration. However, the practicality of NM is often hindered by the challenge of computing and inverting the Hessian matrix. Consequently, a class of second-order optimization methods, termed Quasi-Newton (QN), emerged, aiming to approximate the inverse Hessian matrix, denoted $\bm{\mathrm{B}}$, during the optimization process. This involves updating $\bm{\mathrm{B}}$ iteratively alongside each optimization step. Algorithm [2](https://arxiv.org/html/2508.12270v1#alg2) presents a summary of the QN optimization approach.

### F.2 Symmetric-Rank-One (SR1)

One prominent Quasi-Newton (QN) method is the Symmetric-Rank-One (SR1) technique, which involves iteratively accumulating symmetric rank-one matrices to estimate $\bm{\mathrm{B}}$. Let $\bm{\mathrm{g}}_{k}=\nabla f(\bm{\mathrm{x}}_{k})$ and $\bm{\mathrm{B}}_{k}=\bm{\mathrm{H}}^{-1}(\bm{\mathrm{x}}_{k})$ denote the gradient and inverse Hessian at step $k$, respectively. Considering the linear approximation of $\bm{\mathrm{g}}_{k+1}$ as:

$$ $\bm{\mathrm{g}}_{k+1}=\bm{\mathrm{g}}_{k}+\bm{\mathrm{H}}(\bm{\mathrm{x}}_{k})\left(\bm{\mathrm{x}}_{k+1}-\bm{\mathrm{x}}_{k}\right),$ (17) $$

and defining $\bm{\mathrm{p}}_{k}=\bm{\mathrm{x}}_{k+1}-\bm{\mathrm{x}}_{k}$ and $\bm{\mathrm{q}}_{k}=\bm{\mathrm{g}}_{k+1}-\bm{\mathrm{g}}_{k1}$, equation ([17](https://arxiv.org/html/2508.12270v1#A6.E17)) reduces to:

$$ $\bm{\mathrm{p}}_{k}=\bm{\mathrm{B}}_{k}\cdot\bm{\mathrm{q}}_{k}.$ (18) $$

This equation imposes a constraint directly on $\bm{\mathrm{B}}_{k}$, known as the "secant constraint".

The SR1 method involves updating $\bm{\mathrm{B}}$ with rank-one matrices of the form:

$$ $\bm{\mathrm{B}}_{k}\leftarrow\bm{\mathrm{B}}_{k-1}+\bm{\mathrm{u}}\bm{\mathrm{v}}^{\mathrm{T}},$ (19) $$

where $\bm{\mathrm{u}},\bm{\mathrm{v}}\in\mathbb{R}^{N}$. Assuming $\bm{\mathrm{B}}_{k-1}$ is symmetric, $\bm{\mathrm{B}}_{k}$ is symmetric as well. Enforcing the secant constraint given in equation ([18](https://arxiv.org/html/2508.12270v1#A6.E18)) on $\bm{\mathrm{B}}_{k}$ yields:

$$ $\bm{\mathrm{p}}_{k}=\left(\bm{\mathrm{B}}_{k-1}+\bm{\mathrm{u}}\bm{\mathrm{v}}^{\mathrm{T}}\right)\cdot\bm{\mathrm{q}}_{k},$ (20) $$

which can be rearranged as:

$$ $\bm{\mathrm{u}}=\frac{\bm{\mathrm{p}}_{k}-\bm{\mathrm{B}}_{k-1}\bm{\mathrm{q}}_{k}}{\bm{\mathrm{v}}^{\mathrm{T}}\bm{\mathrm{q}}_{k}}.$ (21) $$

This implies that for every $\bm{\mathrm{v}}\not\perp\bm{\mathrm{q}}_{k}$, a suitable $\bm{\mathrm{u}}$ satisfying the secant constraint can be found. A common choice is $\bm{\mathrm{v}}=\bm{\mathrm{p}}_{k}-\bm{\mathrm{B}}_{k-1}\bm{\mathrm{q}}_{k}$, leading to the following SR1 update step:

$$ $\bm{\mathrm{B}}_{k}\leftarrow\bm{\mathrm{B}}_{k-1}+\frac{\left(\bm{\mathrm{p}}_{k}-\bm{\mathrm{B}}_{k-1}\bm{\mathrm{q}}_{k}\right)\left(\bm{\mathrm{p}}_{k}-\bm{\mathrm{B}}_{k-1}\bm{\mathrm{q}}_{k}\right)^{\mathrm{T}}}{\left(\bm{\mathrm{p}}_{k}-\bm{\mathrm{B}}_{k-1}\bm{\mathrm{q}}_{k}\right)^{\mathrm{T}}\bm{\mathrm{q}}_{k}}.$ (22) $$

The SR1 ’Update B’ process, summarized in Algorithm [3](https://arxiv.org/html/2508.12270v1#alg3), notably ensures the symmetry of the estimated $\bm{\mathrm{B}}$, a desirable feature. However, it falls short in guaranteeing positivity, a crucially property, as emphasized in the subsequent lemma.

###### Lemma 1 .

Let $f\in\mathcal{C}^{2}$ be an objective function, and $\bm{\mathrm{d}}_{\text{NM}}=-\bm{\mathrm{B}}\ \bm{\mathrm{g}}$ represent the Newton direction. Then, $\bm{\mathrm{B}}\succcurlyeq\bm{\mathrm{0}}$ ensures that $\bm{\mathrm{d}}_{\text{NM}}$ is a descent direction.

###### Proof.

$\bm{\mathrm{d}}_{\text{NM}}$ is a descent direction if and only if the directional derivative of $f$ in the direction $\bm{\mathrm{d}}_{\text{NM}}$ satisfies $f^{\prime}_{\bm{\mathrm{d}}_{\text{NM}}}\leq 0$. Since $f^{\prime}_{\bm{\mathrm{d}}}=\bm{\mathrm{g}}^{\mathrm{T}}\bm{\mathrm{d}}$,

$$ $0\geq f^{\prime}_{\bm{\mathrm{d}}_{\text{NM}}}=\bm{\mathrm{g}}^{\mathrm{T}}\bm{\mathrm{d}}_{\text{NM}}=-\bm{\mathrm{g}}^{\mathrm{T}}\bm{\mathrm{B}}\ \bm{\mathrm{g}}\Leftrightarrow\bm{\mathrm{g}}^{\mathrm{T}}\bm{\mathrm{B}}\ \bm{\mathrm{g}}\geq 0$ (23) $$

Hence, $\bm{\mathrm{B}}\succcurlyeq\bm{\mathrm{0}}$ is a sufficient condition ensuring $\bm{\mathrm{d}}_{\text{NM}}$ is a descent direction.
∎

Consequently, several methods have been proposed to either eliminate ’bad’ directions or ensure positive matrices through more sophisticated schemes.

Figure: Algorithm 2 Quasi-Newton (QN) Optimization

Figure: Algorithm 3 Update B (SR1)

###### Lemma 1 .

###### Proof.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 4
presentation: 2
questions: How does L-SR1 perform on tasks beyond HMR?

There is no visual comparison for HMR. It would be better if visual comparisons could be included in Figure 5.
soundness: 3
strengths: A lightweight, self-supervised learned optimizer that integrates a trainable preconditioning unit into the SR1 framework is introduced.

A learned projection mechanism that enforces both the secant condition and positive semi-definiteness, preserving core Quasi-Newton properties within a learned architecture is introduced. 

Experiments show that the proposed method works well on HMR. 

The paper is well written and easy to read.
summary: This paper presents a learned second-order optimizer, named Learned-SR1 (L-SR1), which proposes to use a trainable preconditioning unit to enhance the classical Symmetric-Rank-One (SR1) algorithm while ensuring positive definite preconditioning matrices that satisfy the
secant constraint. The proposed method shows superiority over existing optimizers in benchmark tasks such as Human Mesh Recovery (HMR), and also demonstrates the highest performance profile and converging to the global minimum faster.
weaknesses: The claimed generalization of the proposed Learned-SR1 is not effectively validated. Currently, there is only simple evaluation on HMR task, and the compared baselines do not represent the current state-of-the-art for HMR. 

The paper lacks comparison with more optimization algorithms, e.g., AdamW, AdaHessian, etc. Moreover, the theretical analysis of the learned projection mechanism is insufficient. 

Currently, the evaluation is conducted only on a single dataset (3DPW), which fails to demonstrate the effectiveness and robustness of the proposed method. 

This work lacks a thorough ablation study for each design in the proposed method.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. As a reviewer not deeply familiar with optimizers, I am unclear about the specific contribution of this work in the optimization field. While the authors propose an improved SR1 method, I am uncertain whether such approaches are common or novel in optimization research.
2. Ignoring novelty, the work is valuable as it applies learned optimizers to SR1. The authors appear to address key challenges in adapting SR1 into a learned framework.
3. I have some concerns regarding the sufficiency of the experimental validation. The evaluation is primarily centered on the Monocular Human Mesh Recovery (HMR) task. I am curious to know in which other tasks or domains this method could be effectively applied. HMR itself can be addressed by both optimization-based methods (e.g., SMPLify) and regression-based approaches. This leads to a question of whether the proposed method is specifically tailored to similar iterative optimization frameworks. If so, its potential application domain might be somewhat limited, though I acknowledge this could be a general challenge for the field of learned optimizers rather than a specific shortcoming of this paper.
4. Furthermore, the comparative analysis in the experiments appears relatively limited. For instance, Table 1 primarily reports results on the 3DPW dataset. It would strengthen the paper to include comparisons on other standard benchmarks in this domain. Additionally, the baseline methods used for comparison seem to be from 2020 or earlier. Including comparisons with more recent state-of-the-art approaches would provide a more compelling and up-to-date demonstration of the method's competitiveness.
soundness: 3
strengths: The theoretical foundation of this work is  presented with clarity.
summary: This work introduces ​​L-SR1 (Learned Symmetric-Rank-One)​​, a novel learned second-order optimizer that enhances the classical SR1 algorithm by integrating a lightweight, trainable preconditioning unit. This unit generates data-driven vectors to construct positive semi-definite rank-one matrices, with a key innovation being a learned projection mechanism that enforces the critical secant condition.
weaknesses: The method is only tested on HMR, a specific application in image processing.
It is not know whether this method is applicable or not for other tasks.

---

confidence: 3
contribution: 1
initial_rating: 2
presentation: 2
questions: - Why was HMR selected as the experimental testbed, and which limitations of existing HMR approaches does this work seek to overcome? The connections between the proposed method and the HMR are unclear. Please elaborate with stronger justification.

- Justification of Optimization: The fundamental advantage of optimization-based methods is often their ability to achieve higher accuracy by iteratively refining the fit to the image evidence. However, given that your method's performance (PA-MPJPE: 51.58) lags significantly behind current state-of-the-art learning-based methods (e.g., PromptHMR [CVPR 2025]: 36.6; CameraHMR [3DV 2025]: 35.1), the following question arises: If the accuracy of your optimization-based method is not superior to, and in fact is substantially worse than, its learning-based counterparts, what is the practical and methodological significance of using a much slower optimization approach?

- Scope of “no annotations / no fine-tuning.” For HMR, please specify the exact inner objective (2D keypoints? camera model? masks/contours?), any external detectors used, and how this complies with the “no annotations” claim; otherwise, the “10% data surpasses full training” result is hard to interpret. 

- Supervision boundary. Clarify “no annotated data / no fine-tuning”: what signals supervise HMR (e.g., only 2D keypoints?), what detector(s) and confidence treatment are used, and how is the 10% data experiment constructed (splits, metrics, variance)?

- Discuss failure cases (e.g., heavy occlusion, noisy 2D keypoints input, temporal consistency).
soundness: 2
strengths: - Principled design bridging QN and learning. The method is explicitly grounded in the QN update​, the secant condition, and the need for PSD preconditioners for descent directions; the learned projection aims to satisfy both simultaneously.


- Lightweight, limited-memory, dimension-invariant formulation. L-SR1 uses rank-one outer products with a fixed-size buffer and element-wise modules to generalize across problem sizes without retraining.


- Learned projection and per-coordinate step sizes. The optimizer integrates a vector generator and per-coordinate learning-rate generator; the projection improves convergence while keeping the model compact.
summary: The paper proposes L-SR1, a learned second-order optimizer that augments classical SR1 with a trainable low-rank preconditioner and a learned projection that enforces both the secant constraint and positive semidefiniteness, then applies it to analytic functions and monocular HMR.
weaknesses: - **Insufficient Comparative Analysis**: The paper should compare against a wider set of HMR methods (both optimization-based and modern learned/learnable refiners beyond LGD/SPIN) and report more metrics (e.g., MPJPE, PA-MPJPE, PVE, jitter/contact, temporal stability) on more datasets (e.g., Human3.6M, EHF, AGORA) under matched settings. As written, the HMR main table includes only a few baselines. Moreover, the paper fails to provide an analysis of the computational cost and runtime of the proposed method versus more competitors beyond LGD. This essential data is needed to properly highlight the claimed efficiency.

- **Poor Visual Quality**: A major concern is the poor visual alignment of the fitted SMPL models in Figure 5 and Figure 9. For example, the case in the third row of Fig. 9 is clearly misaligned with the input image in the leg area. The meshes frequently appear misaligned with the subjects in the original images, suggesting a lack of robustness.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. Are any consistency checks or safeguard mechanisms (such as trimming, damping, or fallback) applied during inference? Please provide a small table reporting the constraint residuals at each test step, the proportion of failed steps, and the frequency of guardrail activations.
2. Please supplement the performance profile using exactly the same number of iterations and/or the same wall-clock budget. Additionally, include a curve showing the time or number of steps required to reach the target error, ensuring that the conclusions are not affected by asymmetric budgets or unbalanced rollout lengths.
3. Please provide a small grid or heatmap varying buffer length, unroll steps, projection penalty weight, and learning-rate scaling, and report the final error, the number of steps needed to reach the target, the proportion of bad steps, and the variance across random seeds.
soundness: 3
strengths: 1. The paper proposes a trainable preconditioning unit that augments classical SR1 using data-driven rank-one components and a learned projection that enforces secant consistency while keeping the preconditioner positive semi-definite. This represents an uncommon and creative combination in the learned-optimizer space.
2. It reframes the question of how to satisfy the secant constraint without losing positive semi-definiteness as a learnable projection or penalty design, which removes a long-standing instability of SR1 in a way that is amenable to meta-learning.
3. On quadratic functions and classic benchmarks, the method with the learned projection shows faster decrease and better alignment with a high-quality direction. The performance-profile evaluation indicates the best overall profile among baselines, reflecting a solid and standardized methodology.
4. In HMR (3DPW), the approach improves accuracy over a learned gradient descent baseline while using fewer parameters. The reported curves and tables show the steps to the best error and the model size, following known evaluation protocols.
5. The paper clearly explains the SR1 background, introduces the learned components and projection, and then transitions to analytic and real-world experiments with a consistent and coherent narrative.
6. The work addresses a real pain point in learned optimization. Most learned optimizers are still first-order methods, while this approach advances learned second-order optimization with a lightweight and stable design, lowering the barrier to effectively using curvature information in practice.
summary: Based on the SR1 concept, this paper proposes a Learnable Second-Order Precondition (L-SR1) that learns a positive semi-definite low-rank precondition through three lightweight modules: an input encoder, a vector generator, and a coordinate-wise learning rate generator. A secant-line consistency penalty is introduced during meta-training to enforce constraints, without adding any extra computation during inference. The proposed method is verified on analytical benchmark function families and humanoid mesh recovery (HMR, 3DPW). After replacing the update module of LGD in HMR, L-SR1 achieves higher accuracy, fewer steps, and fewer parameters, demonstrating clear advantages in data efficiency and computational and memory cost.
weaknesses: 1. The main comparisons are with LGD and an LBFGS variant, but the table omits many recent HMR systems and learned optimizers that are well recognized in the community. Please include fair, apples-to-apples comparisons with at least one or two recent strong HMR frameworks (using the same 2D detections and evaluation protocol) and add a modern learned optimizer baseline (e.g., transformer-based) under the same iteration budget.
2. The ablations cover hidden size and encoder inputs, but not the parameters that likely affect stability and generalization, such as buffer length, unroll steps, secant-penalty weight, and learning-rate scaling. Please provide a grid or heatmap over buffer length × unroll steps × penalty weight × LR scale, reporting final error, iterations to target, failure or “bad-step” rate, and variance across random seeds.
3. It is not entirely clear how the buffer, base matrix, and generated vectors interact during inference beyond the training-time penalty. Please add clear, step-by-step pseudocode for inference, along with a table reporting test-time constraint residuals, curvature–direction alignment, and any guardrails used (e.g., fallback or damping).


Decision: Reject