Verbalized Machine Learning: Revisiting Machine Learning with Language Models

## Abstract

Abstract Motivated by the progress made by large language models (LLMs), we introduce the framework of verbalized machine learning (VML). In contrast to conventional machine learning (ML) models that are typically optimized over a continuous parameter space, VML constrains the parameter space to be human-interpretable natural language. Such a constraint leads to a new perspective of function approximation, where an LLM with a text prompt can be viewed as a function parameterized by the text prompt. Guided by this perspective, we revisit classical ML problems, such as regression and classification, and find that these problems can be solved by an LLM-parameterized learner and optimizer. The major advantages of VML include (1) easy encoding of inductive bias: prior knowledge about the problem and hypothesis class can be encoded in natural language and fed into the LLM-parameterized learner; (2) automatic model class selection: the optimizer can automatically select a model class based on data and verbalized prior knowledge, and it can update the model class during training; and (3) interpretable learner updates: the LLM-parameterized optimizer can provide explanations for why an update is performed. We empirically verify the effectiveness of VML, and hope that VML can serve as a stepping stone to stronger interpretability.

### 1 Introduction

The unprecedented success of large language models (LLMs) has changed the way people solve new problems in machine learning. Compared to conventional end-to-end training where a neural network is trained from scratch on some curated dataset, it has become increasingly more popular to leverage a pretrained LLM and design good prompts that contain in-context examples and effective instructions. These two ways of problem-solving lead to an intriguing comparison. Traditionally, we would optimize a neural network in *a continuous numerical space* using gradient descent, while in the new approach, we optimize the input prompt of an LLM in *a discrete natural language space*. Since a neural network is effectively a function parameterized by its numerical weight parameters, can a pretrained LLM act as a function that is parameterized by its natural language prompt?

Driven by this question, we conceptualize the framework of verbalized machine learning (VML), which uses natural language as the representation of the model parameter space. The core idea behind VML is that we can define a machine learning model using natural language, and the training of such a model is based on the iterative update of natural language. This framework enables many new possibilities for interpretability, as the decision rules and patterns learned from data are stored and summarized in natural language. Specifically, we propose to view the input text prompt of LLMs as the model parameters that are being learned. However, optimization over such a natural language parameter space also introduces additional difficulties. Inspired by previous work [, ] where the optimizer is viewed as a function parameterized by a neural network, we parameterize the optimizer function as another LLM, which produces the next-step model parameters by taking in the current model parameters, a batch of training data points, and the loss function. Therefore, VML requires the optimizer LLM to update the learner LLM iteratively such that the training objective can be reached.

Compared to conventional numerical machine learning, the VML framework brings a few unique advantages. First, VML introduces an easy and unified way to encode inductive bias into the model. Because the model parameters are fully characterized by human-interpretable natural language, one can easily enter the inductive bias using language. This linguistic parameterization makes machine learning models fully interpretable and adjustable. For example, if the input and output data are observed to be linearly correlated, then one can use this sentence as part of text prompt. How to effectively encode inductive bias is actually a longstanding problem in machine learning, and VML provides a unified way to inject the inductive bias through natural language—just like teaching a human learner. Second, VML performs automatic model selection during the learning process. The optimizer LLM can automatically select a suitable model class based on the training data and verbalized prior knowledge. Third, each update of the model is fully interpretable in the sense that the optimizer LLM can give an explanation of why it chooses such an update. One can even interact with the optimizer LLM in order to inject new prior knowledge or obtain detailed reasoning.

VML can be viewed as a natural generalization of in-context learning (ICL). Specifically, ICL is a single-step implicit learning process, while VML is a multi-step iterative learning process where the in-context examples are summarized into verbal pattern and knowledge. Moreover, VML provides a way of scaling inference-time compute [, ]. Compared to the best-of-N re-sampling, VML iteratively updates its model parameter prompt by taking into account the learner’s past predictions.

An important concept of VML is its unified token-level representation of both data and model. Unlike numerical machine learning, language models in VML do not differentiate data and model, and treat both of them as part of the text prompt. This shares a striking connection to stored-program computers, also known as the von Neumann architecture, where the key idea is to represent programs as data rather than wiring setups. The link between language models and stored-program computers underscores the importance of text prompts, which play a similar role to computer programs, and, along with LLMs, can become a powerful zero-shot problem solver. Our contributions are as follows:

- •
We formulate the framework of verbalized machine learning, where pretrained language models are viewed as function approximators parameterized by their text prompts. Then, we revisit some classical machine learning problems and show that VML is able to solve them.
- •
We design a concrete VML algorithm with a text prompt template. This algorithm parameterizes both the learner model and the optimizer as LLMs, and enables the iterative verbalized training.
- •
We conduct an empirical study for the injection of verbalized inductive bias and show that it is promising to use natural language as a unified way to encode prior knowledge.
- •
We validate the effectiveness of VML in different applications (Section 4, Appendix B,C,D,E).

### 2 Related Work

LLMs for planning and optimization. Language models are used to perform planning for embodied agents [, , , ], such that they can follow natural language instruction to complete complex tasks. More recently, LLMs have been used to solve optimization problems []. Specifically, the LLM generates a new solution to an optimization problem from a prompt that contains previously generated solutions and their loss values. The LLM optimizer in [] shares a high-level similarity to our work, as we also aim to solve an optimization problem with LLMs. The key difference to [] is our function approximation view of LLMs, which enables us to revisit classical machine learning problems and solve them through natural language in the VML framework.

Natural language to facilitate learning. [, , , , ] show that natural language captions serve as an effective supervision to learn transferable visual representation. [, , , , , ] find that natural language descriptions can easily be turned into zero-shot classification criteria for images. [] proposes to use natural language as latent parameters to characterize different tasks in few-shot learning. In contrast to prior work, VML directly uses the text prompt of LLMs to parameterize functions and learns the language-based model parameters in a data-driven fashion.

Prompt engineering and optimization. There are many prompting methods [, , , , , , ] designed to elicit the reasoning ability of LLMs. To reduce the hand-crafting efforts in designing good prompts, automatic prompt optimization [, , , , , , , , ] has been proposed.
Unlike prompt optimization where the text prompt is optimized without changing its semantic meaning, VML updates its language-based model parameters by adding or modifying the model prior information, making the learner model fully interpretable about its prediction.

LLMs for multi-agent systems. Due to the strong instruction-following ability, LLMs are capable of playing different roles in a multi-agent systems. [, , , ] study a multi-agent collaboration system for solving complex tasks like software development. VML can also be viewed as a two-agent system where one LLM plays the role of learner and the other LLM plays the role of optimizer.

### 3 Verbalized Machine Learning

#### 3.1 From Numerical to Verbalized Machine Learning

Figure: Figure 1: A comparison between numerical machine learning and VML.
Refer to caption: x1.png

Classical machine learning models (*e.g.*, neural networks) are typically trained in a numerical and continuous parameter space. Once trained, these models are stored as a collection of numbers that are not interpretable and remain a black box. Motivated by the strong universal problem-solving capability of LLMs, we find it appealing to view an LLM as a function approximator parameterized by its text prompt. This perspective leads to the VML framework. Similar to a general-purpose modern computer whose functionality is defined by its running program, a function that is defined by an LLM is characterized by its text prompt. Due to the fully human-interpretable text prompt, the VML framework provides strong interpretability and is also easy to trace the cause of model failure. Figure 1 gives a comparison between numerical machine learning and VML. In the VML framework, both data and model are represented in a unified token-based format, while numerical machine learning treats data and model parameters differently.

#### 3.2 Natural Language as the Model Parameter Space

VML parameterizes a machine-learning model with natural language. More formally, VML places a strong constraint on the model parameters $\bm{\theta}=\{\theta_{1},\theta_{2},\cdots,\theta_{t}\}\in\Theta_{\text{
language}}$ to exchange for interpretability, where $\bm{\theta}$ is a text token sequence, $\theta_{t}\in\mathcal{A},\forall t$ is some text token from a large token set $\mathcal{A}$, and $\Theta_{\text{language}}$ denotes the set of all natural language sequences that humans can understand. The model parameter space in VML has the following properties: (1) discrete: the natural language space is discrete; (2) sequential: the natural language space is sequential, and the next word is dependent on its previous words. In contrast, the parameter space in numerical machine learning is not sequentially dependent; and (3) human-interpretable: the natural language that characterizes the model is human-interpretable. More discussion is given in Appendix G.

One of the most significant advantages to use natural language as the model parameters is the easy incorporation of our prior knowledge about the problem and the desired inductive bias into the model training. When the model parameters get updated during training, the model is fully interpretable, and one can observe and understand what gets added and what is modified. Our empirical evidences also supports our interpretability claim, as we find that the model parameters $\bm{\theta}$ are typically a language description of the underlying pattern that the model discovers from the training data.

#### 3.3 Language Models as Function Approximators

The core idea behind VML is using a language model to act as a function approximator parameterized by its natural language prompt. Specifically, we denote the language model as $f(\bm{x};\bm{\theta})$ where $\bm{x}$ is the input data and $\bm{\theta}$ is the function parameter. Both $\bm{x}$ and $\bm{\theta}$ are represented with text tokens. In VML, $f(\cdot)$ is typically a frozen language model that is pretrained on a large corpus of text (*e.g.*, Llama-3 [], ChatGPT). If we consider a static function, we can set the temperature parameter of the LLM as zero, which theoretically makes the output deterministic. If we set the temperature high (see Appendix F for more discussion), $f(\bm{x};\bm{\theta})$ can be viewed as sampling a value from some distribution.

We revisit how a classical machine learning problem is formulated in the VML framework. Suppose we have $N$ data points $\{\bm{x}_{n},y_{n}\}_{n=1}^{N}$ in total, where $\bm{x}_{n}$ is the data vector and $y_{n}$ is the target value. As an example, we consider a least square regression problem using the LLM-parameterized function:

$$ $\min_{\bm{\theta}}\ell_{\text{regression}}:=\frac{1}{2N}\sum_{n=1}^{N}\big{(}y _{n}-f_{\text{model}}(\bm{x}_{n};\bm{\theta})\big{)}^{2},\quad~{}\text{s.t.}~{ }~{}\bm{\theta}\in\Theta_{\text{language}}$ (1) $$

where minimizing the objective function with respect to the discrete token-based model parameters $\bm{\theta}$ is actually quite difficult. Back-propagating gradients through discrete variables (*e.g.*, policy gradients, Gumbel-softmax []) is typically known to be sample-inefficient and sub-optimal.

Figure: Figure 2: An overview of iterative optimization and text prompt templates of the learner and the optimizer in the regression example.
Refer to caption: x2.png

#### 3.4 Iterative Training by Prompt Optimization

Because the model parameters $\bm{\theta}$ in VML form a text prompt, optimizing $\bm{\theta}$ is effectively a prompt optimization problem. Different from the prompt optimization problem [], where the goal is to produce a generic prompt without adding new information, the training in VML focuses on updating the model’s language characterization, which involves both the addition of new prior information and the modification of existing information. To optimize our model parameters, we start by looking at the gradient of the regression objective function in Equation 1:

$$ $\nabla_{\bm{\theta}}\ell_{\text{regression}}=\frac{1}{N}\sum_{i=1}^{N}\big{(}y _{n}-f_{\text{model}}(\bm{x}_{n};\bm{\theta})\big{)}\cdot\frac{\partial f_{ \text{model}}(\bm{x}_{n};\bm{\theta})}{\partial\bm{\theta}},\quad~{}\text{s.t. }~{}~{}\bm{\theta}-\eta\cdot\nabla_{\bm{\theta}}\ell_{\text{regression}}\in \Theta_{\text{language}}$ (2) $$

Figure: Algorithm 1 Training in VML

where $\eta$ is the learning rate, and the constraint is to ensure that the updated model parameters are still in the human-interpretable natural language space. It seems to be infeasible to compute this gradient. To address this, we view the gradient as a function of the data $(\bm{x},y)$ and the current model parameters $\bm{\theta}$. Then we directly approximate the next-step model parameters using another pretrained language model denoted by $f_{\text{opt}}(\bm{x},\hat{y},y,\bm{\theta};\bm{\psi})$ where $\hat{y}$ is the model prediction from the learner $f_{\text{model}}$. $\bm{\psi}$ denotes the optimizer parameters that characterizes the optimizer settings, and we can use language to specify the update speed, the momemtum, *etc*. The largest possible batch size of the optimizer LLM is determined by its context window. The optimizer LLM can already output natural language that satisfies the constraint, so we simply ask the LLM to play the optimizer role, which has been shown quite effective in []. More importantly, the performance of our VML framework gets better as the instruction-following ability of LLMs gets stronger. An overview of the iterative optimization and the text prompt templates of the learner and optimizer in the regression example are given in Figure 2. The detailed algorithmic training procedure is given in Algorithm 1.

Using an LLM as the optimizer offers several unique advantages. First, the optimizer can perform automatic model selection. When the learner model can not make correct predictions for the training data, the optimizer will automatically update the learner to a more complex and capable model (see the polynomial regression experiments in Section 4.2 as an example). Second, the optimizer can provide detailed explanations of why a particular update should be performed, which helps us to understand the inner working mechanism of the optimization process. Third, the LLM-parameterized optimizer allows users to interact with it directly. This not only helps us to trace model failures, but it also allows us to inject prior knowledge to improve optimization (even during training).

Different optimizer parameterizations. Here we use a *direct parameterization*, *i.e.*, parameterizing the optimizer as a single function $f_{\text{opt}}$, which couples the gradient and the update functions together.
Alternatively, we can use an *indirect parameterization* where the gradient and the update are two separate LLM-parameterized functions. The gradients are known as “textual gradients” in prompt optimization [, ]. The update of learner’s model parameter is given by $\bm{\theta}_{i}=f_{\text{update}}(\bm{\theta}_{i-1}.\frac{\partial\ell}{
\partial\bm{\theta}})$, where $\frac{\partial\ell}{\partial\bm{\theta}}$ is computed by $f_{\text{grad}}(\frac{\partial\ell}{\partial\hat{\bm{y}}},\bm{\theta}_{i-1})$ and similarly, $\frac{\partial\ell}{\partial\hat{\bm{y}}}$ is computed by $f_{\text{grad}}(\ell,\hat{\bm{y}})$. Both $f_{\text{update}}$ and $f_{\text{grad}}$ are parameterized by LLMs. Compared to direct parameterization that takes one LLM call, this process takes several LLM calls. We compare both methods in Section 4.8 and Section A.3.

#### 3.5 Discussions and Insights

VML as a unified framework to encode inductive bias. A unified framework to encode arbitrary inductive bias has been pursued for decades. For different types of data, we need to design different models to encode the inductive bias (*e.g.*, graphical models [] for random variables, recurrent networks [] for sequences, graph networks [] for graphs, and convolution networks [] for images). VML uses a unified natural language portal to take in inductive biases, making it very flexible for encoding complex inductive bias. To incorporate an inductive bias about the hypothesis class or prior knowledge about the problem, we can simply concatenate a system prompt $\bm{\theta}_{\text{prior}}$ (*i.e.*, some constant prefixed text that describes the inductive bias) with the model parameters $\bm{\theta}$. Therefore, the final model parameters are $(\bm{\theta}_{\text{prior}},\bm{\theta})$ where only $\bm{\theta}$ is learnable and $\bm{\theta}_{\text{prior}}$ is provided by users.

Difference between VML and prompt optimization. Both VML and prompt optimization aims to automatically produce a text prompt towards some target, but VML differs from existing prompt optimization works (*e.g.*, [, ]) in a substantial way. First, VML aims to automatically discover a data pattern description that acts as the the model parameters for the LLM learner, while prompt optimization seeks a generic instruction without changing the original meaning to elicit the best downstream question-answering performance. We qualitatively compare the difference of their learned prompts in the experiment section. Second, prompt optimization can be viewed as a building block for VML, as its techniques can be naturally adapted for the training of VML.

VML enables interpretable knowledge discovery. Because the model parameters $\bm{\theta}$ are already in natural language, it is easy to understand the underlying pattern that leads to the prediction and the decision rules that the model uses. Unlike numerical machine learning, this property enables VML to discover novel knowledge that humans can also learn from.

VML as “the von Neumann architecture” in machine learning. Machine learning usually treats the model parameters and the data differently, similar to the Harvard architecture that stores instruction and data separately. VML stores both data and model parameters in the text prompt as tokens, which resembles the von Neumann architecture that stores instruction and data in the same memory.

### 4 Applications and Case Studies

We demonstrate the features and advantages of VML by revisiting some classical machine learning tasks followed by a realistic medical image classification task.
In these tasks, we are given data $\mathcal{D}_{\text{train}}=\{{\bm{x}}_{n},y_{n}\}_{n=1}^{N}$, and we want to find $\bm{\theta}^{*}$ such that $f_{\text{model}}({\bm{x}};\bm{\theta}^{*})$ best describes the mapping ${\bm{x}}\to y$.
Our experiments below show in detail how VML is able to solve these tasks and find $\bm{\theta}^{*}$.

Experiment setups. We use the instruction-tuned Llama-3 70B [] for the LLM unless specified otherwise.
The training set for each task consists of $100$ data points.
For all tasks, we use a batch size of $10$ for each step of optimization (see Figure 2 (right) as an example), which corresponds to $10$ steps per epoch of training.
To evaluate regression performance, we look at the training loss, and the model predictions in both the interpolation and extrapolation settings.
As for classifications, we use additional test sets consist of $20$ data points, and evaluate the training and testing accuracies.
During optimization, inspired by the idea of momentum from classical machine learning optimization, we also provide the last step (*i.e.*, one step only) of the optimization history to stabilize training.

Training logs. The results of our experiments are showed using:
(a) training loss, which is computed by *parsing* the model output (string) and *converting* it in to the same data type as the target value ($y$), then we use mean squared error for regression, and zero-one loss mean (*i.e.*, average accuracy) for classification.
The computed training loss is for logging purpose only, it is not required for training in VML (see Algorithm 1).;
(b) visualization of the learned model, which is also done through *parsing* and *converting* the model output;
(c) the model parameter at each training step $i$ before optimization (*i.e.*, $\theta_{i-1}$), and the optimizer output for the updated $\theta_{i}$.
For $i>1$, the full model parameter before optimization is $\bm{\theta}_{i-1}=\{\theta_{0},\theta_{i-1}\}$, but in our figures below we only show the $\theta_{i-1}$ to save space.

Compute. The LLM is ran on a node of $8\times\text{A100}$ using the inference engine provided by vLLM [].
During each step ($i$) of training, we query the LLM $10$ times for evaluating the model $f_{\text{model}}({\bm{x}};\bm{\theta}_{i-1})$ over a batch, and $1$ time for requesting the newly optimized $\bm{\theta}_{i}$.
We also evaluate the entire test set at each step, which, depending on the size of the evaluation set, requires between $20$ to $100$ LLM queries.
Overall, for the regression tasks, they take around $10$ minutes for each epoch of training.
The classification tasks, take around $16$ minutes for each epoch of training.
An additional $6$-minute overhead arises due to evaluating the grid for the background of the decision boundary.

#### 4.1 Linear Regression

Figure: Figure 3: Training dynamics for VML based linear regression. The model is trained for 2 epochs, each with 10 steps.
Refer to caption: x3.png

We generate $\mathcal{D}_{\text{train}}$ from a linear function with Gaussian noise, *i.e.*, $y=3x+4+\epsilon$, where $\epsilon\sim\mathcal{N}(0,1)$ and $x\sim\mathcal{U}(0,2)$.
We initialize the model parameter $\bm{\theta}_{0}$ by *only* specifying that the task is a regression task from $\mathbb{R}$ to $\mathbb{R}$ (see Figure 3(c) Step 1).
Figure 3(a) shows that training improves the model, and that it converges.
The subplots (b) and (c) show details of the model and optimization at steps 1, 3 and 15.
At step 1, since $\bm{\theta}_{0}$ only contain the definition of 1-D regression task, the
$\text{model}_{0}$
is randomly guessing (see the dashdot line).
The *
$\text{optimizer}_{1}$
says that* it notices a linear relationship between the input and the target outputs, hence introducing a linear regression model to capture such a relationship, which results in
$\text{model}_{1}$
being a straight line.
From step 2 onward, the optimization focus switches to fitting the identified linear regression model to the data.
For example, at step 3, we can see that
$\text{optimizer}_{3}$
*says* it notices that the outputs of
$\text{model}_{2}$
are generally smaller than the target, suggesting the scaling factor is too small, hence it increases it.
Similarly, at step 15,
$\text{optimizer}_{15}$
also *says* it notices the
$\text{model}_{14}$
overestimates the target; hence, it reduces the scaling factor.
We can see from (b) that the resulting
$\text{model}_{15}$
closely approximates the ground truth.

#### 4.2 Polynomial Regression

Figure: Figure 4: Training dynamic for VML based polynomial regression. The model is trained for 2 epochs, each with 10 steps.
Refer to caption: x4.png

We generate $\mathcal{D}_{\text{train}}$ from a polynomial function with Gaussian noise, *i.e.*, $y=3x^{2}+x+2+\epsilon$, where $\epsilon\sim\mathcal{N}(0,1)$ and $x\sim\mathcal{U}(-3,1)$.
Similarly, $\bm{\theta}_{0}$ is initialized by *only* specifying that the task is a regression task from $\mathbb{R}$ to $\mathbb{R}$ (see Figure 4(c) Step 1).
Figure 4(a) shows that training is effective and converges.
Subplots (b) and (c) show details of the model and optimization at steps 1, 2 and 3.
At step 1,
$\text{model}_{0}$
randomly guesses the outputs.
The *
$\text{optimizer}_{1}$
says that* it notices $y$ has a larger range than $x$, and that they seem to have positive correlation; therefore, it updates
$\text{model}_{1}$
to be a simple linear model.
This linear model assumption leads to a jump in the training loss (see subplot (a)), as it is far from the ground truth.
Consecutively, at step 2,
$\text{optimizer}_{2}$
*says* the poor performance makes it realize that the linear model oversimplifies the relationship between $x$ and $y$.
It notices a non-linearity between $x$ and $y$, and to capture this, it uses a quadratic model.
This results in a better model and leads to a large decrease in the training loss.
At step 3,
$\text{optimizer}_{3}$
switches from model class selection to fitting the quadratic model.
The resulting
$\text{model}_{3}$
closely fits the ground truth.

#### 4.3 Sinusoidal Regression

Figure: Figure 5: Demonstration of prior injection, and comparison between Llama-3, GPT-4o and a neural net in the setting of sinusoidal regression.
Refer to caption: x5.png

Figure: Figure 6: Linearly separable two blobs classification based on VML. (b) plots the decision boundary of model with $\bm{\theta}_{i-1}$ at step $i$.
Refer to caption: x6.png

We generate $\mathcal{D}_{\text{train}}$ from a sine function with Gaussian noise, *i.e.*, $y=\sin(x)+2+0.01\epsilon$, where $\epsilon\sim\mathcal{N}(0,1)$ and $x\sim\mathcal{U}(-3,3)$.
Fitting a sine function is known to be difficult for neural nets in terms of extrapolation.
Here, we try GPT-4o, a more powerful model than Llama-3.
Figure 5(b; right) shows that when $\bm{\theta}_{0}$ contains *only* the definition of 1-D regression, it results in a linear model after training (see (c; right)).
We can *add a prior to $\bm{\theta}$ by simply saying* that the data looks like samples generated from a periodic function, which results in a very good approximation and it extrapolates much better than a neural net (see (b,c; left)).
But adding the same prior to Llama-3 is not as effective (see (b,c; mid)), indicating the capability of VML depends on the capability of the underlying LLM. However, we note that, the effectiveness of VML improves along with the capability of the LLM.

#### 4.4 Two Blobs Classification

We generate a linearly separable $\mathcal{D}_{\text{train}}$ from two blobs on a 2-D plane.
$\bm{\theta}_{0}$ is initialized by *only* specifying that the task is binary classification on a 2-D plane (see Figure 6(c) Step 1).
Subplot (a) shows that training is effective and that it converges.
At step 1,
$\text{optimizer}_{1}$
*says* its inspection of the current batch of data has the pattern that data points with $x>0$ belong to class 2, and data points with $x<0$ belong to class 1; hence it updates
$\text{model}_{1}$
to have a linear decision boundary at $x=0$, which happens to be perfect.
However, Figure 6(a) shows that the training loss does not immediately converge.
We can investigate the cause and “*debug*” the optimizer by looking at what
$\text{optimizer}_{2}$
says.
From (c) Step 2, we see that
$\text{optimizer}_{2}$
*says*
$\text{model}_{1}$
is already quite simple and accurate, but it wants to further improve the model and utilize the new information from the current batch.
Guided by this reasoning,
$\text{model}_{80}$
becomes a very deep decision tree, and the decision boundary has a reasonable margin towards the data (see Figure 6(b, c; right)).

#### 4.5 Two Circles Classification

We generate a non-linearly separable $\mathcal{D}_{\text{train}}$ by creating data points on two concentric circles for the two classes.
Besides the definition of binary classification on a 2-D plane, we also add a sentence to encode our inductive bias that the decision boundary is a circle into $\bm{\theta}_{0}$ (see Figure 7(c) Step 1).
At step 1,
$\text{optimizer}_{1}$
utilizes the prior information, and updates
$\text{model}_{1}$
to have a circle decision boundary.
For the rest of the training step, the optimizer mainly tries to find a good fit for the radius and the center of the decision boundary.
At step 41,
$\text{optimizer}_{41}$
*says*
$\text{model}_{40}$
seems to be a good fit for the data, and no changes are needed, hence, it uses the same $\bm{\theta}_{40}$ for
$\text{model}_{41}$
.
Without the prior, VML can also learn a good model, but the performance shows large variance at the beginning of training (see Figure 7(a; dashed)) due to the model class selection process similar to Figure 3(a).
Figure 7(c; bottom right) shows the resulting $\bm{\theta}_{40}$ without the prior, which is a decision tree.

Figure: Figure 7: Non-linearly separable two circles classification with a prior in $\bm{\theta}$. (a; dashed) and (c; bottom right) also show results without the prior.
Refer to caption: x7.png

#### 4.6 Qualitative Comparison Between Prompt Optimization and VML

Figure: Figure 8: VML versus a prompt optimization method (Automatic Prompt Engineer []).
Refer to caption: x8.png

To differentiate VML from prompt optimization, we qualitatively compare VML to a popular prompt optimization method called Automatic Prompt Engineer (APE) [] on two tasks.

Linear regression as in Section 4.1.
Figure 8(a) shows that the result from APE is vague and general.
Such a description can easily be derived by humans through visual inspection of the data, and it does not learn deeper insights from the data, whereas VML is able to learn useful new information that is difficult to derive by visual inspection of the data.
We can see that VML is doing pattern recognition, which is different from naive prompt optimization.

Text classification. Adopted from the Google BIG-bench[], the task is to classify whether a name is more likely to be associated to female or male.
Figure 8(b) shows that APE does return a correct description of the task, but it is, once again, very general.
Conversely, VML is able to learn more detailed knowledge about the data pattern which cannot be done easily through visual inspection.

#### 4.7 Medical Image Classification

Figure: Figure 9: Tiny-PneumoniaMNIST image classification for models with and without prior at initialization.
Refer to caption: x9.png

To demonstrate the capability of VML beyond simple machine learning problems, we include an experiment to demonstrate the effectiveness of VML in image classification.
We use GPT-4o, which supports visual inputs, to take into account both image and text data.
The task is to classify whether an input X-ray image has indications of pneumonia or not, see Figure 9(b) for image examples.
Due to the cost of requesting GPT-4o, we create a subset of the dataset PneumoniaMNIST [].
Our dataset consists of 100 training data and 100 test data (half pneumonia and half normal for both sets).
Models are trained for 5 epochs.
We try out two different model parameter initializations, one with prior and one without.
We encode the inductive bias by simply adding a sentence as the prior, which states that the input is an X-ray image for identifying pneumonia, along with the definition of binary image classification (see Figure 9(c)).
The test accuracy in (a) shows that both models are able to improve their performance on the task as the training epoch increases, and the model initialized with prior also outperforms the model without (in terms of both testing accuracy and training convergence).
Additionally, by inspecting the parameters of
$\text{model}_{50}$
(see (d)), we can observe that the model parameters $\bm{\theta}_{50}$ for the learner *with prior* has more medical domain knowledge associated to features of pneumonia (such as “acute infection”, “pneumatocele formation”), while the model parameters $\bm{\theta}_{50}$ for the learner *without any prior* mainly use generic visual knowledge associated to features of lung (such as “visible opacities”, “uniform texture”). This observation well validates the effectiveness of using natural language to describe and encode inductive bias. More importantly, our experiment demonstrates the usefulness of learning in VML (*i.e.*, the generalization performance can be improved over time), which is also one of the key differences to existing prompt engineering methods.
Additionally, the interpretable nature of the learned model parameters in VML is crucial for applications in medical domain.
The learned models can be validated by medical professionals, and their predictions are grounded by their verbalized reasonings.

#### 4.8 Ablation Study and Exploratory Experiments

**Table 1: Comparison between VML and ICL on previous applications (without adding any prior information).**
| Task | Reg-L($\downarrow$) | Reg-P($\downarrow$) | Cls-TB($\uparrow$) | Cls-TC($\uparrow$) | Cls-MI($\uparrow$) |
| --- | --- | --- | --- | --- | --- |
| ICL | 0.38 | 62.96 | 100% | 95% | 48% |
| VML | 0.12 | 2.38 | 100% | 95% | 74% |

Quantitative comparison to in-context learning. Since VML can be viewed as a generalization of ICL, we compare VML to ICL in all previous applications. Results are given in Table 1. The ICL results are chosen from the best across 5 runs. The metrics used for regression (Reg) and classification (Cls) are mean square error (MSE $\downarrow$) and test accuracy ($\uparrow$), respectively. We abbreviate linear regression as Reg-L, polynomial regression as Reg-P, two blob classification as Cls-TB, two circle classification as Cls-TC and medical image classification as Cls-MI. The results show that VML consistently outperforms ICL in all scenarios.

Figure: Figure 10: Training loss for ablation study. For each configuration, we show 5 individual runs (thin) and their mean (thick).
Refer to caption: x10.png

Scaling effect with stronger LLMs. We are interested in whether the performance of VML can be improved using a stronger LLM. We use Llama-3.1 with different size (8B, 70B, 405B) as the backbone LLM for VML. From Figure 10(a), we see that stronger LLMs (*e.g.*, 405B) learn faster and achieve lower loss in the linear regression setting (Section 4.1).

Direct vs. indirect parameterization. As discussed in Section 3.4, we have a direct and indirect way to parameterize the optimizer. We compare both parameterization using the linear regression setting in Section 4.1. Figure 10(b) shows that the direct parameterization outperforms the indirect one.
The direct parameterization is also more efficient and requires less LLM calls. Detailed experimental settings and discussions are given in Section A.3.

#### 4.9 VML Enables Robust Mathematical Reasoning

Figure: Figure 11: VML is able to learn to reason and solve symbolically generated GSM8K [] questions with Llama-3.1-8B.
Refer to caption: x11.png

Figure: Figure 12: Binary digit pattern discovery of 4-integer vectors. No prior is injected to the model parameter in this experiment.
Refer to caption: x12.png

Recent work [] shows that if we modify the original GSM8K [] question by changing only the variable values (*e.g.*, Figure 11(a)), the accuracy of many LLMs on the modified dataset will decline, which might be due to data contamination during pretraining.
Our experiments show that VML can reduce such a performance variation and enable robust mathematical reasoning without changing the internal weights of LLMs. Specifically, we randomly generate a training set and a test set, both of size 100 (without overlap), using the template in Figure 11(a).
If we directly evaluate the test set using Llama-3.1-8B, the average accuracy over 5 runs is around 80%.
We use VML to learn a set of instructions for this task, the initial one is given in Figure 11(c).
We use a batch size of 10 and train for 10 steps.
Figure 11(b) shows that, on average over 5 runs, the test performance increases with the number of training step, and VML enables the model to achieve achieves 98% accuracy on the test set.
Figure 11(d) shows the optimization outputs for step 1, 3, and 6 for a selected run in Figure 11(b).
We can see that after step 1, the new instructions already recover the correct mathematical reasoning for the task, but the test accuracy is only around 91%.
At step 3,
$\text{optimizer}_{3}$
realizes that the error is mostly due the inaccurate calculations rather than the correctness of the instructions for
$\text{model}_{2}$
.
Hence, the new instructions for
$\text{model}_{3}$
includes emphasis on calculation verification, which brings the test performance up to 96%.
At step 6,
$\text{optimizer}_{6}$
says it notices many of
$\text{model}_{5}$
’s mistakes are still related to incorrect and incomplete calculations, therefore, it breaks down the instructions into a more detailed lists to allow easier reasoning and checking.
Therefore, VML can enable LLMs to improve their reasoning ability at test-time by themselves without changing the internal weights.

#### 4.10 Digit Pattern Discovery

To further demonstrate the interpretability of VML, we create a binary classification task on vectors of 4 digits.
Class 0 contains vectors that only have digit ‘0’ in the first position, and Class 1 contains vectors that only have digit ‘0’ in the last position (see Figure 12(b)).
Our dataset consists of 100 training data and 20 test data (half for both classes).
Models are trained for 5 epochs (*i.e.*, 50 steps with batch size 10). Figure 12(a) shows that both the training and test accuracy improves with the number of steps, hence learning is effective.
The model is initialized with the definition of the task.
During step 1, the optimizer says it notices that the first element of each input is often ‘0’ when the ground truth label is ‘0’, and decides to use a rule-based approach (see (c)).
The resulting model description is half correct, which captures the pattern that ‘if the first element is 0, predicts 0’.
After a few more steps, the optimizer is able to learn the correct description: ‘If the first element is 0, predicts 0. Otherwise, if the last element is 0, predict 1.’
Compared to the regression and 2D plane classification results, the learned model here is more interpretable than learning a neural network.
Also, without any prior information, one will normally choose a universal approximator such as a neural network to solve this task, which will perform equally well but certainly not as interpretable.
We also evaluate the performance of in-context learning (ICL) for this task as a baseline.
Our result shows that VML is able to achieve 100% test accuracy with an interpretable description of the pattern, while ICL can only achieve 87.5% and does not explicitly output a pattern description.

### 5 Concluding Remarks, Limitations and Future Directions

Our paper introduces a verbalized way to perform machine learning and conducts several case studies on regression and classification tasks. The experiments show that VML can effectively perform these classical machine learning tasks, validating the potential of language models as function approximators. Despite the empirical effectiveness, there are a few limitations that remain to be addressed. First, training in VML still suffers from a relatively large variance. This is partially due to the stochasticity from the LLM inference, as well as the prompt design of the optimizer. Second, the output numerical error in LLMs results in inevitable fitting error. Concretely, even if the LLM correctly understands the underlying symbolic expression, there is still an output numerical error when performing inference on specific input values. This also suggests the intrinsic difficulty within LLMs to properly understand numbers (see [, ]). Third, the input data dimensionality and batch size are largely limited by the size of context window in LLMs.

One future direction is to study various aspects in VML using insights and concepts from classical machine learning.
Some interesting questions include:
Can we find a better design for the optimizer so that the training is more robust and efficient?
How does the optimization landscape in VML differ from classical ML, what does it look like?
Another interesting direction is to investigate the learning dynamics of VML, and compare it with how human learns.
Since human also has a language model in mind, the same experiments in the paper can be conducted on human through messaging software.

### Acknowledgment

The connection between LLMs and computers was discussed in our blog(^1^11See the blog entitled “Large Language Models Are Zero-Shot Problem Solvers — Just Like Modern Computers” in [https://timx.me/blog/2023/computers-vs-llms/](https://timx.me/blog/2023/computers-vs-llms/).). The VML framework is naturally motivated by the idea of LLMs acting as a modern computer, since we view the verbalized model parameters as a way to “program” the LLM. We then connect VML to the von Neumann architecture in the sense that both data and program instruction are put in the text prompt in VML.

WL was supported by the German Research Foundation (DFG): SFB 1233, Robust Vision: Inference Principles and Neural Mechanisms, TP XX, project number: 276693517.
This work was partially funded by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy – EXC number 2064/1 – Project number 390727645.
This work was supported by the German Federal Ministry of Education and Research (BMBF): Tübingen AI Center, FKZ: 01IS18039A.
RB acknowledges funding by the German Research Foundation (DFG) for project 448588364 of the Emmy Noether Programme.
The authors thank the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for supporting Tim Z. Xiao.

## Appendix

### Appendix A Details for Ablation Study and Exploratory Experiments

Here we provide additional details for the experiments in Section 4.8.

#### A.1 Comparison Between In-context Learning and VML

In-context learning (ICL) is a popular method for adapting LLMs to downstream tasks.
Here, we compare the performance of VML and ICL in various tasks from previous sections.
For all tasks, we provide the entire training set as in-context examples, and query the individual test data independently.
The resulting predictions for regression and 2D classification are plotted in Figure 13.
The full comparison between VML and ICL are shown in Table 2.
We can see that VML outperforms ICL in regression and medical image classification, and has the same performance to ICL in the simpler classification tasks, *e.g.*, two blobs and two circles.
Within our framework, ICL can be understood as a *nonparameteric* method, while VML is a *parameteric* one (see Section G.3 for more discussion).

Figure: Figure 13: Predictions of in-context learning (ICL) for the same regression and classification tasks with Llama-3 70B.
Refer to caption: x13.png

**Table 2: Test performance for in-context learning (ICL) and verbalized machine learning (VML) on various tasks from previous section (without adding prior information). The ICL results are chosen from the best across 5 runs. The metrics used for regression (Reg) and classification (Cls) are mean square error (MSE $\downarrow$) and test accuracy ($\uparrow$) correspondingly.**
| Task | ($\downarrow$) Reg-Linear | ($\downarrow$) Reg-Poly. | ($\uparrow$) Cls-Two Blobs | ($\uparrow$) Cls-Two Circles | ($\uparrow$) Cls-Medical Img |
| --- | --- | --- | --- | --- | --- |
| VML | 0.12 | 2.38 | 100% | 95% | 74% |
| ICL | 0.38 | 62.96 | 100% | 95% | 48% |

#### A.2 Larger and More Powerful LLMs Learn Faster and Better

To verify whether the performance of VML scale with the capability of LLMs, we compare three Llama-3.1 models of different sizes, *i.e.*, 8B, 70B, and 405B, in the linear regression setting.
Figure 14 shows the training loss of 5 individual runs (thin) and their mean (thick) for each LLM.
Note that due to the high variance nature of using LLMs for optimization, we select the 5 best runs out of 10 runs for this comparison.
We see that more powerful LLMs (*e.g.*, 405B) learn faster and achieve lower training loss.

Figure: Figure 14: Llama-3.1 LLMs scale versus VML training performance in linear regression setting. 5 individual runs (thin) and mean (thick) for each LLM.
Refer to caption: x14.png

#### A.3 Direct and Indirect Optimization

There are different ways to implement the optimization step in VML.
We choose to directly update the model parameters $\bm{\theta}$ in a single LLM call by providing all the necessary information, *i.e.*, $\bm{\theta}_{i}\!\!=\!\!f_{\text{opt}}\big{(}\{\bm{x}_{m},\hat{y}_{m},y_{m}\}_
{m=1}^{M},\bm{\theta}_{i-1};\bm{\psi}\big{)}$ in Algorithm 1.
If we choose a lower abstraction level, we can decompose the *direct* single step optimization into *indirect* multi-step optimization.
Algorithm 2 illustrates how $f_{\text{opt}}$ can be decomposed into four consecutive functions, which resemble the operations of computation graphs in most numerical machine learning frameworks.
Specifically, we calculate the following step-by-step:
(1) the quality of the predictions (*i.e.*, evaluate the loss function $f_{\text{loss}}$);
(2) the ‘gradient’ of the loss $\ell$ w.r.t. the predictions $\bm{\hat{y}}$ denoted as $\partial\,\ell/\partial\,\bm{\hat{y}}$;
(3) the ‘gradient’ of the loss $\ell$ w.r.t. the parameters $\bm{\theta}_{i-1}$ denoted as $\partial\,\ell/\partial\,\bm{\theta}_{i-1}$;
(4) update the current $\bm{\theta}_{i-1}$ to $\bm{\theta}_{i}$ using the ‘gradient’ $\partial\,\ell/\partial\,\bm{\theta}_{i-1}$.
The ‘gradients’ here are known as ‘textual gradients’ in prompt optimization literature [, ], which are essentially text-based feedback from LLMs.

We compare the two approaches in the linear regression setting using Llama-3.1 70B.
Figure 15 shows, for both the direct and indirect optimization, the training loss of 5 individual runs (thin) and their mean (thick).
We can see that the indirect method performs slightly worse than the direct method.
The reason can be there are 3 more prompt templates to design, which is harder than designing just one, and has a higher risk of losing information in the pipeline.

Figure: Algorithm 2 Decomposed $f_{\text{opt}}$

Figure: Figure 15: Training loss of direct and indirect optimization in linear regression setting using Llama-3.1 70B. The lines show 5 individual runs (thin) and mean (thick) for each approach.
Refer to caption: x15.png

### Appendix B Effect of Accurate Loss Feedback

Figure: Figure 16: Training dynamics for two different optimization settings in the polynomial regression setting. One has access to the accurate loss computation, and the other does not.
Refer to caption: x16.png

The VML algorithm at Algorithm 1 specifies that the arguments for $f_{\text{opt}}(\cdot)$ consist of the inputs ${\bm{x}}$, the predictions $\hat{y}$, the targets $y$, the current model parameter $\bm{\theta}_{i-1}$ and the optimizer configurations $\bm{\psi}$.
Hence, there is no explicit definition of the loss function for the optimizer (see Figure 2(right) for an example of the verbalized loss function).
It is up to the optimizer itself to evaluate the difference between the prediction $\hat{y}$ and the target $y$.
We are interested in question that whether having access to the real training loss (defined and computed for logging purpose), mean squared error in this case, can help the optimizer to better navigate the training trajectory.

The orange line in Figure 16(c) shows that having such accurate loss feedback might not help, and might even decrease the performance in this scenario.
One possible explanation is that the single loss value itself does not contain too much information. Moreover, as the exact form of the loss function can be fed to LLM easily, the LLM might spend additional efforts to estimate the exact form of the loss function, which makes the convergence even more difficult. It actually makes intuitive sense that verbalized loss function (*i.e.*, using natural language to explain the target of the loss function) works better in the VML framework.
For example, knowing how does each prediction contributes to the loss value can be more informative and a single overall loss value, since the model might be doing well for some data but not the others, and we only want to improve the model for points with the bad predictions.

### Appendix C Numerical Error of LLMs in Representing Symbolic Functions

Figure: Figure 17: Functions evaluations and numerical error in Llama-3 70B
Refer to caption: x17.png

Figure: Figure 18: Functions evaluations and numerical error in GPT-4o.
Refer to caption: x18.png

LLMs are designed to do language modeling, rather than exact calculations.
Hence, their performance on evaluating functions can be unreliable, and might result in error.
Figure 17 shows that Llama-3 is very comfortable in evaluating the given linear and polynomial function, as the mean is quite accurate.
The variance over 10 runs is also pretty small, except for one or two points.
However, for a more complex function such as $\sin(x)$, Llama-3 is only able to return small error approximately in the range of $x\in(-2,2)$.
Both the error and the variance are large out side of this range.
This explains the non-smoothness for the function in Figure 5(b; right), which has $\sin(x+1.0)$ in the learned model parameters.

By switching to the more powerful model, GPT-4o, we can see from Figure 18 that both the error and the variance decrease.
In particular, for $\sin(x)$, GPT-4o returns smaller error in a larger range, (*i.e.*, $x\in(-2.5,5.0)$).
This implies that as the capability of LLMs improves, their performance in evaluating more complex functions also improves.

Nevertheless, this is currently still a limitation for VML if the optimizer chooses to use complex mathematical functions as the model parameter.
If the evaluation of the function has an error, then during training, the optimizer will update the model parameters based on noisy signal.
This can lead to large variance in training and slow convergence.
Future work should look into methods for minimizing the numerical error in LLMs function evaluation.

Figure: Figure 19: Function evaluations based on the natural language description of the corresponding symbolic sine function.
Refer to caption: x19.png

Figure 19 shows that if we use natural language to describe the symbolic sine function (see sub-figure(a)), GPT-4o is able to produce more accurate evaluations than using the symbolic function (see (c)).
The accuracy of Llama-3 70B also increases, even though it still under performs GPT-4o (see (b)).
This is likely due to Llama-3 is less capable in instruction following than GPT-4o.
This observation implies that in VML, we might want to instruct the optimizer to avoid using complex symbolic functions in the update and to prefer the natural language description of the function.

### Appendix D Mitigating Numerical Error by Tool Calling

In this section, we supplement experiments of Llama-3 70B with a python interpreter.
Despite the fact that LLMs are able to perform numerical data tasks, the incorporation of a python interpreter further improves LLMs ability to deal with numerical values.
Specifically, we use the *open-interpreter*(^2^22GitHub Repo: [https://github.com/OpenInterpreter/open-interpreter](https://github.com/OpenInterpreter/open-interpreter)) library to add a python interpreter to Llama-3 70B, such that the LLM has the ability to use python programs to evaluate symbolic functions or perform numerical operations. We follow the same experimental settings as in Section 4.3 (sinusoidal regression of $y=\sin(x)+2$). The training data is only sampled from $[-3,3]$ with additive Gaussian noise. The in-domain testing data is sampled from the same range, while the out-of-domain testing data is sampled from $[-6,-3]$ and $[3,6]$.

The results are given in Table 3. We can observe that with the python interpreter, Llama-3 70B can effectively learn periodic functions, while in the original experiment (*i.e.*, Figure 5(b)), the same LLM is unable to approximate periodic function even with a prior. The results show that the tool-using ability can further improve the learnability of VML. The example logs for inference with the learned model is showed below.

**Table 3: Evaluation (using mean squared error $\downarrow$) on sinusoidal regression as in Figure 5(b) for three different models including (1) neural networks, (2) Llama3 with prior, and (3) *Llama3 with prior and code interpreter*.**
| Test Domain | Neural Nets | Llama3 with prior | Llama3 with prior and code interpreter |
| --- | --- | --- | --- |
| In Domain | 0.0073 | 0.7385 | 1.0e-05 |
| Out of Domain | 0.5840 | 11.1735 | 1.0e-05 |
| Overall | 0.2345 | 5.956 | 1.0e-05 |

### Appendix E Connection between Prediction Variance and Model Parameters in VML

#### E.1 From Vague to Concrete Model Parameters

Figure: Figure 20: Evaluations on model parameters using vague to concrete descriptions. Results are over 10 runs. The base LLM is Llama-3-70B.
Refer to caption: x20.png

The model parameters generated by a VML optimizer can be vague or concrete.
We are curious for those with vague descriptions, how would the LLM evaluations look like, and whether they have large variance.
Figure 20 shows the results on Llama-3 70B for six different model descriptions, including:

- (a)
None
- (b)
“There is a linear relationship with a positive slope between the input and the output.”
- (c)
“Output = b + a * Input”
- (d)
“Output = b + a * Input, where a is in the range of [0, 6] and b is in the range of [0, 8]”
- (e)
“Output = b + a * Input, where a is in the range of [2, 4] and b is in the range of [3, 5]”
- (f)
“Output = b + a * Input, where a is in the range of [3, 5] and b is in the range of [4, 6]”

(a) shows that if we only provide the information that the task is a regression task and do not specify the model at all, the LLM tends to predict a linear function (slope $\approx 1$) with increasing variance as $x$ moves away from 0 0.
(b) shows that if we specify there is a linear relationship between inputs and outputs, the LLM will predict a linear function with a similar slope as (a) but with smaller variance.
(c) shows that if we specify the explicit form of the linear function, the slope will still be around $1$, but the variance are larger when $x>1$.
(d, e, f) show that by providing a range for the values of the unknown variables, the LLM tends to use the mid-point of the range for the values, and a smaller range does correspond to a smaller variance in prediction.

#### E.2 Semantic Invariance of Model Parameters

Figure: Figure 21: Evaluation on the model parameters from Figure 3(c; Step 15) using six different rephrasing with the same semantic meaning. Results are over 10 runs. The base LLM is Llama-3-70B.
Refer to caption: x21.png

In natural language, there are different ways to express a concept with the same semantic meaning.
Hence, the model parameters generated by a VML optimizer might vary a lot between runs, even though they are semantically invariant.
We are curious whether such variance in descriptions will lead to variance in model evaluations.
Figure 21 shows that results on Llama-3 70B for six different but semantically invariant descriptions of the model from Figure 3(c; Step 15), *i.e.*,:

- (a)
“The new pattern descriptions will be based on a linear regression model with a scaling factor of 3.34 and a bias term of 3.28. The new pattern descriptions are:
y = 3.34x + 3.28
where y is the predicted output and x is the input.”
- (b)
“The updated pattern definitions utilize a linear regression framework characterized by a slope of 3.34 and an intercept of 3.28. The revised pattern equations are expressed as:
y = 3.34x + 3.28
where y denotes the estimated output, and x represents the input variable.”
- (c)
“y = 3.34x + 3.28”
- (d)
“The new pattern descriptions will be derived from a model that predicts outcomes based on input values. This model adjusts the input by a factor of 3.34 and adds a constant value of 3.28 to generate the final prediction. Here, the predicted result is determined by this specific adjustment and addition applied to the input.”
- (e)
“Amidst the dance of numbers, a new design takes form,
Where linear paths converge with elegance and charm.
A scaling factor whispers, ‘Three point three four,’
And bias gently murmurs, ‘Three point two eight,’ no more.
With inputs cradled softly, the pattern does reveal,
A future sketched in numbers, a prophecy made real.
Y, the destined output, unfolds from X’s grace,
In linear harmony, they find their rightful place.
So here it is, the song of y and x entwined,
A mathematical ballet, precision redefined.”
- (f)
{CJK*}
UTF8gbsn
“新图景描述，依循回归模型之法，带有倍数三点三四，偏差三点二八。新图景描绘如下：
心数乘以三点三四，再加上三点二八，便得其意境。
此中，心数为所输入，意境为所输出。”

These rewrites are generated by GPT-4o based on (a).
The description (a) is the original $\bm{\theta}_{15}$ from Figure 3(c; Step 15).
(b) rephrases the descriptions from (a) slightly.
(c) only keeps the symbolic equation from (a).
(d) is a rewrite without using math expression.
(e) uses the poetry style.
(f) is a translation of (a) into Literary Chinese.
The results in Figure 21(a,b,c) are similar, and have small variance across the 10 runs.
The results in Figure 21(d,e,f) are also very accurate on average.
However, the poetry rewrite (e) and the Chinese rewrite (f) do have slightly larger variance.
Overall, we see that if the various descriptions preserve the same semantic, then their evaluations through Llama-3 70B are likely to be similar.

### Appendix F A Probabilistic View on VML

The output of a language model usually comes with randomness. In the paper, we typically consider to set the temperature in LLMs as zero to remove the randomness from sampling, which indicates that LLMs will always output the text with the largest probability (*i.e.*, largest confidence logit). However, we want to highlight that such a sampling process actually gives us another probabilistic perspective to study VML. We will briefly discuss this perspective here.

#### F.1 Posterior Predictive Distribution

Because we can easily sample multiple possible model parameters by setting a proper temperature for the optimizer LLM, we view it as a way to sample multiple learner models. This is well connected to Bayesian neural networks, where Bayesian inference is applied to learn a probability distribution over possible neural networks. We start by writing the posterior predictive distribution ($\mathcal{D}$ is training data):

$$ $p(\hat{y}|\mathcal{D})=\int_{\bm{\theta}}p(\hat{y}|\bm{\theta})p(\bm{\theta}| \mathcal{D})d\bm{\theta}=\mathbb{E}_{p(\bm{\theta}|\mathcal{D})}\big{\{}p(\hat {y}|\bm{\theta})\big{\}}$ (3) $$

where we can easily sample multiple model parameters $\bm{\theta}$ and compute its probability with logits. Specifically, we have that $p(\bm{\theta}|\mathcal{D})=\prod_{t=1}^{n}P(\theta_{t}|\theta_{1},\cdots,
\theta_{t-1},\mathcal{D})$. Using this idea, it is actually quite easy to obtain the ensembled output that is weighted by posterior distribution.

#### F.2 From Functions to Stochastic Processes

With non-zero temperature, we can view the output of LLMs as a sampling process from a distribution over text tokens, which means each output token can be viewed as a random variable. Then the output of LLMs is effectively a sequence of random variables, and therefore it is easy to verify that it is a stochastic process. This view makes it possible for VML to perform probabilistic modeling.

### Appendix G Discussions on Natural Language Model Parameters

There are many interesting properties regarding the natural language model parameters. Many traditional machine learning models can be revisited in the scenario where model parameters are text prompts in the LLM.

#### G.1 Different Mechanisms to Update Model Parameters for Direct Optimization

Naive re-writing. Given the model parameters $\bm{\theta}_{t}$ at the step $t$, the simplest way to update the model parameters at the step $t+1$ is to use whatever the optimizer generates. We denote the optimizer LLM generates the new model parameters $\bm{\theta}_{\text{new}}^{t}$. This is essentially

$$ $\bm{\theta}_{t+1}\leftarrow\bm{\theta}_{\text{new}}^{t}.$ (4) $$

An simple extension to naive re-writing is to add a text prompt to instruct the optimizer LLM to take the previous model parameters $\bm{\theta}_{t}$ into consideration at the step $t+1$. Thus we have the conditional re-writing, namely $\bm{\theta}_{t+1}\leftarrow f_{\text{opt}}(\bm{\theta}_{t})$. This is also what we use in the main paper.

Incremental updating. Alternatively, we can choose to update the model parameters in an incremental fashion without remove the previous model parameters completely. We denote the optimizer LLM generates the new model parameters $\bm{\theta}_{\text{new}}^{t}$. Then the model parameters $\bm{\theta}_{t+1}$ at the step $t+1$ is

$$ $\bm{\theta}_{t+1}\leftarrow\{\bm{\theta}_{t},\bm{\theta}_{\text{new}}^{t}\}.$ (5) $$

However, the incremental updating will make the model parameters an increasingly longer text prompt. This is not ideal since the context window of a LLM is typically quite limited. The incremental updating mechanism can be interpreted as using a small learning rate to train the learner. This will easily lead to bad local minima (because the previous incorrect model parameters will be kept and may affect the future learning as a prior knowledge in the text prompt), but it may improve the training convergence.

Incremental updating with summarization. To avoid the infinite increasing length of model parameters, we can instruct the optimizer LLM to summarize the previous model parameters into a fixed length. This yields

$$ $\bm{\theta}_{t+1}\leftarrow\{\underbrace{\mathcal{C}(\bm{\theta}_{t})}_{\text{ fixed token length}},\bm{\theta}_{\text{new}}^{t}\}.$ (6) $$

where $\mathcal{C}(\cdot)$ is some text summarization scheme.

Connection to standard optimizers. There are many interesting connections between the optimizer LLM and the standard numerical optimizer. Usually the behavior of the optimization is determined by the optimizer parameters $\bm{\psi}$ which is also a text prompt. This is usually a text description of the target of the optimizer. For example, we can instruct the optimizer LLM to serve as the first-order optimizer (*e.g.*, momentum SGD) and feed all the necessary information into the text prompt. Then the optimizer LLM will essentially become an optimizer mapping function that maps all the necessary information (including the previous model parameters) to the model parameters of the next step. To implement the momentum in the optimizer LLM, one can simply instruct the optimizer LLM to maintain the previous model parameters as much as possible. This is to say, everything we want to implement in the optimizer are realized through text prompts. It will inevitably depend on the instruction-following ability of the LLM, and it is possible that there will be some unrealizable optimization functionalities (*e.g.*, we instruct the optimizer LLM to be a second-order optimizer and the optimizer LLM may be likely to ignore this instruction). However, we want to highlight that as LLMs become more powerful, this problem will be less and less significant. In general, implementing an advanced optimizer in VML is still an important open problem.

#### G.2 Occam’s Razor, Constrained-length Model Parameters, and Kolmogorov Complexity

We are interested in how Occam’s razor can be applied in VML. One natural way of doing so is to constrain the model parameters to be a small and fixed length. This essentially is

$$ $\bm{\theta}_{t+1}\leftarrow\{\underbrace{\mathcal{C}(\bm{\theta}_{t})}_{\text{ fixed token length}},\underbrace{\bm{\theta}_{\text{new}}^{t}}_{\text{fixed token length}}\}.$ (7) $$

We can see that as long as we constrain the text token length of the model parameters to be small, the learner will perform an automatic model simplification, as it will try to discover the data pattern with concise and simple text. There are many more ways to implement the Occam’s razor in VML. More interestingly, it is also possible to incorporate a structural constraint to the model parameters. For example, it can be causal knowledge (*e.g.*, text representation of a causal graph), logic formula or decision trees. Our work opens up many more possibilities on Occam’s razor in VML, and rethinking the form of Occam’s razor in VML is very crucial in unlocking the strong interpretability and controllability of inductive biases.

Another perspective on the length of the model parameters in VML is related to Kolmogorov complexity [], which is defined as the shortest effective description length of an object.
The principle of Occam’s razor is basically saying that hypotheses with low Kolmogorov complexity are more probable [].
By constraining the length of model parameters to be small, we are effectively trying to find the minimum description length (MDL) of a model in natural language.
The theoretic Kolmogorov complexity of a model is usually impossible to compute, however, VML might provide an estimation for Kolmogorov complexity by using the shortest effective length of the learned model parameters in natural language.

#### G.3 Connection to Nonparametric Models and In-context Learning

*Nonparameteric* methods get around the problem of model selection by fitting a single model that can adapt its complexity to the data [, , ].
These methods allow the model complexity to grow with the number of observed data.
This is different to *parametric* models which have fixed number of parameters.
In VML, as showed in Section 4.2, the model complexity is also flexible and adapts to the data during training.
Similarly, the concept of in-context learning (ICL) can also be understood as nonparametric methods in the lens of LLMs as function approximators.
ICL denotes the method of using LLMs to solve new tasks by only providing the task demonstrations or examples in the prompt with natural language.
Given a new data point, an LLM predicts its output using information in the provided demonstrations.
From the perspective of VML, ICL in an LLM essentially defines a nonparametric model implicitly using the demonstrated examples in the natural language space.

### Appendix H Broader Discussions

In this section, we use the format of Q&A to discuss a list of interesting topics that are loosely related to VML, but are more broadly tight to the capability of LLMs.
Some of the questions might seen philosophical or ideological, but were asked by fellow researchers before.
Nevertheless, we still include them into this section in case some readers find them insightful.

#### H.1 How is the optimizer’s statement ‘the function should be y = m ∗ x + b 𝑦 𝑚 𝑥 𝑏 y=m*x+b italic_y = italic_m ∗ italic_x + italic_b ’ more interpretable than learning a linear function?

The interpretability from VML is on the framework itself. Using natural language to characterize the model can reveal exactly what pattern the model learns from data, which is very different from training neural networks from scratch. As for the case of regression problems in the paper, interpretability comes from (1) automatic model selection with explanations: this is different from common practice where we assume the data is linear and use a linear regression model. In our experiment, we don’t have such a prior and the optimizer will learn this linear pattern purely by exploring the data. The closest equivalent from classical ML methods would be to train an “universal approximator”, *e.g.*, a neural networks, which might decide to fit a function that is roughly linear, but has a lot more parameters and less interpretable; (2) another source of interpretability comes from the property that the user can easily interact with the optimizer and follow up with more questions to seek explanations.

#### H.2 Is controlling the hyperparameters of LLM optimizers, such as learning rate and regularization, more difficult than controlling those of traditional ML optimizers?

Exploring the hyperparameters of LLM optimizers is important yet challenging. It is a great research question for VML. One of the reasons that VML is particularly interesting is that it brings a lot of new research questions.

LLM optimizers have both advantages and disadvantages. The precise control of learning rate and momentum can be difficult. However, adding the qualitative effect of high/slow learning rate and momentum is in fact quite easy. One can simply use language to describe it. In our optimizer prompt, we use the concept of momentum (*e.g.*, “update the model parameter without changing it too much” and provide a constant amount of optimization histories). In terms of regularization, it is also easy to add regularization to control the complexity of the model in VML, *e.g.*, the word length of the model parameters (*i.e.*, a form of Occam’s razor). A qualitative hyperparameter control for LLM optimizers is simple, while this can be challenging for classic ML.

#### H.3 LLMs are optimized for natural language understanding and generation, not for numerical data tasks typically associated with machine learning. Are LLMs fundamentally restricted for machine learning tasks?

Numerical data tasks are heavily studied in LLMs, for example, mathematical problem-solving. The popular MATH dataset [] requires strong numerical data processing from LLMs, and this dataset is used as a standard evaluation benchmark for LLMs. Moreover, there exists many LLMs (*e.g.*, DeepseekMath [], WizardMath []) that are capable of solving competition-level mathematics problems.

Moreover, LLMs have shown remarkable potential in numerical data tasks for machine learning, and our work is one of the first methods to reveal such a potential. Some concurrent works [, ] also gave empirical evidence that LLMs can be fundamentally suitable for machine learning tasks.

Verbalized machine learning aims to provide a framework for LLMs to deal with machine learning tasks, with the ability to fully interpret the learned knowledge with natural language. We believe this framework will be increasingly more powerful, as LLMs get more powerful. We have already observed the performance improvement of VML by switching from Llama-3 to GPT-4o.

#### H.4 The fundamental nature of LLMs is to predict (the next token) based on a probability distribution over the vocabulary. One might argue this process is based on statistical choice rather than on true understanding. Is it meaningful to use LLMs for applications such as machine learning tasks?

We believe VML does represent a meaningful direction to explore, as there is current no evidence that LLMs can not perform ML tasks. On the other hand, we already have quite a few applications that demonstrate the effectiveness of VML (*e.g.*. medical image classification). In fact, even in-context learning can already perform a few ML tasks (as introduced by GPT-2 and GPT-3 papers [, ]). We believe there are a lot of applications to be unlocked in the VML framework.

Whether one should use LLMs for tasks other than language modeling is indeed an important open question, which is currently under active research with a significant number of researchers in the field investigating the boundary of LLMs’ capability, and trying to explain the ‘seemingly’ emergence of such abilities from the simple language modeling training objective.

The argument that LLMs can not elicit true understanding due to its statistical training is debatable. Firstly, it is unclear what it means to train a model based on true understanding. One can not perform such a training without an explicit form of loss function. On the other hand, there are some analyses that show that next-token prediction induces a universal learner []. Secondly, we believe that there is a distinct difference between low-level statistical training and high-level knowledge understanding. Whether one can induce another is unknown and is also out of the scope of our paper.

Currently, there has already been substantial evidence that LLMs possess a form of understanding that is functionally relevant for many real-world tasks. The fact that they can consistently generate useful and accurate outputs across various domains, including numerical math [, ], theorem proving [], biology [] (just to name a few), challenges the argument that LLMs lack real understanding.

Hence, we believe to argue against the use of LLMs for tasks other than language modeling, such as math related problems, will require an equally substantial amount of empirical evidence or theoretical proof, which is missing at the moment.

#### H.5 Hallucination remains a significant issue for LLMs. How can we trust them to handle complex tasks such as VML?

Even though hallucination is an observation associated with LLMs, it does not fundamentally limit the performance of VML. We rarely encounter failure of VML due to hallucination in our experiments. The model in VML is parameterized by a text prompt. Whether the learned model (*i.e.*, the text prompt) is acceptable depends on the test performance (*e.g.*, the training accuracy) of a task. If the LLM-based optimizer hallucinated during VML training, the resulting model parameter (*i.e.*, the text prompt) is unlikely to have a good performance consistently across the test dataset. If the learned good performing model parameter seems unexpected, it is more likely that the LLM-based optimizer discovered new knowledge from the training data than have hallucinated.

Additionally, we see that hallucination becomes less of a problem today than a year ago, due to the more powerful model and continuous efforts from the community (*e.g.*, a lot of LLM alignment and scalable oversight methods are proposed recently). We believe VML is actually an orthogonal & independent contribution to existing LLM research topics such as hallucination. VML studies how to enable interpretable learning using natural language. As LLM gets more powerful and more faithful, VML will also become more useful.

### Appendix I Complete Training Template at Initialization

#### I.1 Linear Regression

Figure: Figure 22: Prompt templates of VML for the learner and optimizer for the linear regression (Llama-3-70B without prior).
Refer to caption: x22.png

#### I.2 Polynomial Regression

Figure: Figure 23: Prompt templates of VML for the learner and optimizer for the polynomial regression (Llama-3-70B without prior).
Refer to caption: x23.png

#### I.3 Sinusoidal Regression

Figure: Figure 24: Prompt templates of VML for the learner and optimizer for the sinusoidal regression (GPT-4o with *prior*).
Refer to caption: x24.png

#### I.4 Two Blobs Classification

Figure: Figure 25: Prompt templates of VML for the learner and optimizer for the two blobs classification (Llama-3-70B without prior).
Refer to caption: x25.png

#### I.5 Two Circles Classification

Figure: Figure 26: Prompt templates of VML for the learner and optimizer for the two circles classification (Llama-3-70B with prior).
Refer to caption: x26.png

#### I.6 Text classification

Figure: Figure 27: Prompt templates of VML for the learner and optimizer for the text classification (Llama-3-70B without prior).
Refer to caption: x27.png

### Appendix J Detailed Training History

#### J.1 Linear Regression (Llama-3-70B without prior)

#### J.2 Polynomial Regression (Llama-3-70B without prior)

#### J.3 Sinusoidal Regression (GPT-4o with prior)

#### J.4 Two Blobs Regression (LLama-3-70B without prior)

#### J.5 Two Circles Regression (LLama-3-70B without prior)

#### J.6 Two Circles Regression (LLama-3-70B with prior)

#### J.7 Text Classification (LLama-3-70B without prior)

#### J.8 Medical Image Classification (GPT-4o with prior)

#### J.9 Medical Image Classification (GPT-4o without prior)

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 3
questions: My main question lies in the motivation behind proposing the VLM framework for classical machine learning tasks.
soundness: 2
strengths: The idea of parameterizing a machine-learning model with natural language is niche. The new framework, Verbalized Machine Learning (VML), may be used to explain and distinguish between traditional machine learning and LLM-based learning schemas.
summary: This paper introduces a framework called Verbalized Machine Learning (VML), which constrains the parameter space to human-interpretable natural language. In this framework, the input prompt of a large language model (LLM) is optimized within the discrete natural language space, and an optimizer LLM iteratively updates the parameters of the learner LLM. VML is more interpretable and adjustable than traditional machine learning as all components are characterized by human-understandable natural language.
weaknesses: -	The novelty and contribution seem marginal. It is not surprising that LLM-based VML can address classical machine learning problems. Additionally, the core of VML relies on using two LLMs in a role-playing manner as a learner and an optimizer, updating LLMs through prompt engineering, which does not yield significant scientific insights.
-	I find it unclear how the millions and billions of parameters of a language model are represented by natural language. While prompting is an effective way to optimize a model’s output, I do not agree that optimizing model parameters is effectively a prompt optimization problem (Line 161). For example, in Figure 2, the prompt serves more as an additional input to the model rather than representing model parameters. In other words, the prompt adds new contextual information to the input without necessarily changing the model itself.
-	This framework only functions with LLMs that are adept at following instructions, which limits its applicability to smaller or non-instruction-based models.
-	The framework has been tested on regression and classification tasks, which traditional machine learning models can handle quite well. It is unclear to me why it is worth applying this LLM-based VML framework, especially considering the potential costs and computational expense.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 4
questions: Interpretability is claimed as a benefit of VML framework, but I am uncertain about the actual benefit. For example, Line 515-516 "validated by medical professional". My confusion is: what does it take for a professional to inspect the "model parameter"? If the model parameter is like a document-long, the practitioner might be better off by not using the system right?
soundness: 2
strengths: * illustration and mathematical formulation are very clear.
summary: In this paper, the author propose to frame conventional machine learning with LLM as Verbalized Machine Learning: casting the "model parameters" to be the input language to the modeling LLM; and "parameter update" as language feedback from an optimizer LLM. This allows major advantages of VML include (1) easy encoding of inductive bias; (2) automatic model class selection; and (3) interpretable learner updates.
weaknesses: * I do not understand the additional benefit (beyond iterative prompting methods e.g. [3] or retrieval-augmented generator model) provided by this general framework. For example,

1. Using LLM to solve basic numerical computation has been shown to be hard by previous work [1]. Therefore, LLM doesn't seem to be a fit for more advanced calculation like regression. Also, the "classical ML problems" in the paper like regression models are very simple cases, but I do not believe such observation could be extrapolated to more advanced ML setting.

2. Figure 6: couldn't a conventional decision tree achieve the same level of predictive power and interpretability? In VML framework, if the LLM is not good at instruction following anywhere during reading the "model parameter".

3. The author claim VML brings the benefit of encoding human interpretable prior, but the examples given are a bit simple, like "Prior: The input is X-ray image for identifying pneumonia." (Figure 9). And the benefit of such prior seems to be unstable (Figure 9a). Have the author tried to experiment with more complicated prior? or shows more stable benefit over "without prior"?

* Such framework seems to make so strong assumptions --- optimizer LLM are essentially treated as an oracle machine; and the LLM needs to be very strong and faithful (to input) LLM. However, LLM has been shown to be brittle for explanation [2]. If such strong assumption is put on the backbone model, the same level of efforts (to get such a strong LLM) could be spent on alternative framework (a framework to unify various approaches from like a better decision tree, or other interpretable classifier) to achieve the same desiderate claimed by VML; and the "conventional ML" models from such alternative framework could run with much higher efficiency than serving an LLM.



[1]: Faith and Fate: Limits of Transformers on Compositionality
[2]: The Unreliability of Explanations in Few-shot Prompting for Textual Reasoning
[3]: Learning to Retrieve Iteratively for In-Context Learning

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: For the training dynamics plots across model scales, i.e. Fig 10 a), it'd be more clear if the authors can change the x-axis to be the FLOPs instead of step size.
soundness: 2
strengths: - This paper explores the potential of using LLMs in optimization and learning. The perspective and ideas are novel.
- Overall the paper is well written and conveys the key ideas clearly with a good amount of details.
- The experiments that support the claims are thorough and well designed.
summary: This paper proposed a new framework of using LLMs as the backbones of machine learning tasks. The authors illustrated and verified the ideas using several simple ML tasks, and demonstrated that the approach is feasible. Furthermore, the authors also conducted ablations to show that the method is more effective than merely prompt optimization.
weaknesses: - To make a strong argument of the generality of this new framework, the paper would need more results to show how practical it is, such as including empirical results measuring the efficiency of this approach. I'd also expect the paper to discuss the scalability of this approach, e.g. how it scales with amount of training data and size of the LLM being used. Given that this approach is not suitable for all or most machine learning tasks, the paper should carve out a concrete area of tasks which the proposed approach shines. 
- Since the major differentiator with prior work, e.g. Yang et al. is the function approximation view of LLM, the paper should provide some theoretical analysis of what functions could and could not be approximated, and which properties of the LLMs architecture pose constraints, etc.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: See weakness
soundness: 1
strengths: The paper studies a general and timely problem.

The main experiments cover multiple classical ML problems. The paper also presents some pilot results on image classification problems beyonds language tasks.
summary: This paper introduces Verbalized Machine Learning (VML), a framework that uses natural language (text prompts) as the parameter space for machine learning models. VLM represents model parameters as text prompts, and uses an optimizer LLM to improve the prompts of the learner LLM. The paper mainly tests the proposed on a series of classical ML problems  such as linear regression, polynomial regression, and shows the proposed framework can enable learning textual prompts for these problems.
weaknesses: Overall, regarding technical contributions, the paper does not sufficiently differentiate the proposed technique from existing prompt optimization approaches and prior work using LLMs as optimizers. At the same time, the paper does not provide enough comparison against these baseline approaches. Specifically:

The proposed approach is essentially optimizing textual prompts for a learner LLM using an optimizer LLM (as acknowledged in line 160 of the paper). This has been explored in previous prompt optimization work (Pryzant, et al., 2023; Yang et al., 2023; Yuksekgonul et al., 2024; Zhang et al., 2024). The paper states the difference as  "prompt optimization seeks a generic instruction tuning without changing the original meaning." (line 233),
I am not sure if I can buy this claim, modern prompt optimization techniques do have more specific edits in the prompts (e.g., see the examples in appendices of Yang et al., 23 and Zhang et al., 2024).

Moreover, the paper lacks experimental comparisons against these related approaches. The evaluation mainly focuses on regression tasks. The only comparison with prior prompt optimization work is in Section 4.6, which provides a qualitative comparison against APE on text classification. (It's also worth noting that APE is primarily a search-based approach without LLM optimizers, making it a less relevant baseline). In order to clearly show the difference of VLM against prior approaches, it is necessary to compare to up-to-date prompt optimization approaches (Pryzant, et al., 2023; Yang et al., 2023; Yuksekgonul et al., 2024; Zhang et al., 2024) across a broader range of tasks under a controlled computational budget setting.


LARGE LANGUAGE MODELS AS OPTIMIZERS (Yang et al., 23)

Automatic Prompt Optimization with “Gradient Descent” and Beam Search (Pryzant et al., 23)

TextGrad: Automatic "Differentiation" via Text (Pryzant et al., 24)

In-Context Principle Learning from Mistakes (Zhang et al., 24)

---

confidence: 5
contribution: 4
initial_rating: 6
presentation: 4
questions: Please see weakness
soundness: 4
strengths: * Good presentation
* VLM is interesting and provides a new perspective on machine learning.
* This paper investigates two important problems in machine learning: classification and regression.
summary: The paper introduces Verbalized Machine Learning (VML), a framework that leverages large language models (LLMs) to address machine learning problems by constraining the parameter space to human-interpretable natural language. VML treats the LLM's text prompt as model parameters, enabling the model to be optimized over a discrete, sequential, and interpretable space. The framework offers advantages such as easy encoding of inductive bias, automatic model class selection, and interpretable learner updates. The paper empirically evaluates VML's effectiveness on various tasks, including regression, classification, and medical image classification, demonstrating its potential for enhancing interpretability and trustworthiness in machine learning.
weaknesses: * Lack of dicussion and comparison with [1]. [1] introduce agent symbolic learning, a systematic framework that enables language agents to optimize themselves on their own in a data-centric way using symbolic optimizers.
* I found that training loss is not stable in Figure 10. Is common in VML? 





------------------------------------
[1] Symbolic Learning Enables Self-Evolving Agents. https://arxiv.org/abs/2406.18532