Montessori-Instruct: Generate Influential Training Data Tailored for Student Learning

## Abstract

Abstract Synthetic data has been widely used to train large language models, but their generative nature inevitably introduces noisy, non-informative, and misleading learning signals. In this paper, we propose Montessori-Instruct , a novel data synthesis framework that tailors the data synthesis ability of the teacher language model toward the student language model’s learning process. Specifically, we utilize local data influence of synthetic training data points on students to characterize students’ learning preferences. Then, we train the teacher model with Direct Preference Optimization (DPO) to generate synthetic data tailored toward student learning preferences. Experiments with Llama3-8B-Instruct (teacher) and Llama3-8B (student) on Alpaca Eval and MT-Bench demonstrate that Montessori-Instruct significantly outperforms standard synthesis methods by 18.35% and 46.24% relatively. Our method also beats data synthesized by a stronger teacher model, GPT-4o. Further analysis confirms the benefits of teacher’s learning to generate more influential training data in the student’s improved learning, the advantages of local data influence in accurately measuring student preferences, and the robustness of Montessori-Instruct across different student models. Our code and data are open-sourced at https://github.com/cxcscmu/Montessori-Instruct .

## 1 Introduction

Synthetic training data is highly effective in various applications of large language models (LLMs) (Lu et al., ), spanning from general pretraining (Allal et al., ; Zhou et al., ), instruction-tuning (Tong et al., ) to domain-specific scenarios such as mathematics (Yu et al., ) and coding (Jiang et al., ).
The advantages of synthetic data include its low cost, convenience, and flexibility, making them an appealing choice for scaling up training data (Yue et al., ), mitigating the shortage of human labels (Chang et al., ), and improving data diversity (Sun et al., ).

Typical data synthesis methods (Wang et al., ) employ an instruction-tuned teacher model and prompt it with seed data to generate synthetic training data for a student model.
It is widely observed that the teacher-generated data can be noisy and non-informative (Bauer et al., ), their simple and uniform format may lead to pattern overfitting (Chen et al., ), and their biased and ungrounded content can introduce ambiguity in AI alignment (Liu et al., ).
These are fundamental challenges of synthetic data as they can mislead students and sometimes even result in model collapse (Shumailov et al., ; Seddik et al., ).

In this paper, we propose Montessori-Instruct, a novel data synthesis framework designed to generate more tailored and informative data by directly optimizing the synthesis ability of the teacher toward the student’s learning preferences. We first leverage influence functions (Koh & Liang, ; Yu et al., ) to precisely measure the utility of synthetic data–its ability to effectively train the students. Then, we optimize the parameters of the teacher model according to the student’s preferences through Direct Preference Optimization (DPO) (Rafailov et al., ).
The preference-optimized teacher then synthesizes influential training data for the students.
As shown in Figure 1,
rather than employing LLM-as-a-judge (Zheng et al., ) to evaluate and filter data by quality (Yuan et al., ) or prompting teachers to generate harder examples (Lee et al., ),
Montessori-Instruct directly optimizes the teacher according to students’ learning preferences, leading to more customized, flexible, and effective synthetic training data for the students.

Figure: (a) Self-Instruct
Refer to caption: x1.png

Our experiments use Montessori-Instruct to synthesize 10K instruction-response pairs with Llama3-8B-Instruct (Meta, ) as teacher and train Llama3-8B/Tinyllama-1.1B (Zhang et al., ) as students. The results show that Montessori-Instruct achieves relative improvements of 18.35% and 46.24% over Self-Instruct on in-domain Alpaca Eval (Dubois et al., ) and out-of-domain MT-Bench (Zheng et al., ), respectively.
The benefits of Montessori-Instruct are more pronounced compared to state-of-the-art data synthesis methods such as Self-Reward and LLM2LLM, as well as data synthesized by the cutting-edge LLM, GPT-4o (OpenAI, ).
The results on a wide range of general NLP tasks (e.g., MMLU (Hendrycks et al., ) and GSM8K (Cobbe et al., )) further demonstrate the generalization capabilities of Montessori-Instruct.

Further analyses reveal a strong correlation between the teacher’s optimization process and the student’s performance, demonstrating that Montessori-Instruct enables the teacher to generate data aligned with students’ preferences to enhance its learning. Ablation studies highlight the advantages of using data influence to reflect students’ preferences, the effectiveness of optimizing the teacher parameters over solely bootstrapping the data, and the robustness of Montessori-Instruct across different seed data, multiple iterations, and a variety of student models.

Our main contributions are summarized as follows:

- 1.
We propose Montessori-Instruct, a novel data synthesis framework that tailors the data synthesis ability of the teacher toward the student’s learning.
- 2.
We incorporate influence functions to accurately capture the student’s data preferences and effectively guide the teacher’s optimization directions.
- 3.
Our empirical results demonstrate the effectiveness and robustness of Montessori-Instruct in improving students’ learning outcomes by tailoring synthetic data generation to align with student learning preferences.

## 2 Related work

Synthetic data has been shown highly effective in various applications of large language models  (Lu et al., ), including pretraining (Allal et al., ; Zhou et al., ), instruction-tuning (Tong et al., ; Yue et al., ), mathematics (Yu et al., ) and coding (Jiang et al., ). Typical approaches like Self-Instruct (Wang et al., ) leverages an instruction-tuned teacher to generate instruction-response pairs given a small amount of seed data. Following the similar pipeline, Self-Guide (Zhao et al., ) and Self-Alignment (Sun et al., ; Guo et al., ) further enhance data quality for specific tasks, such as safety, truthfulness, and instruction-following, by carefully curating task-relevant seeds.
In parallel, Instruction Backtranslation (Li et al., ) and Bonito (Nayak et al., ) collect massive texts from the internet as responses, prompt LLMs to synthesize instructions reversely, and select high-quality candidates.

Despite its promising potential, synthetic data primarily rely on the teacher’s free-form generations, thus is inevitably often biased, non-informative, and misleading (Bauer et al., ; Liu et al., ).
The discrepancy between synthetic data and real-world sources often results in a misalignment with human values and preferences (Liu et al., ), raising the risk of training student models that are biased (Feng et al., ; Liu et al., ), ungrounded (Liu et al., ; Patel & Pavlick, ), or misrepresentative of real-world scenarios (Ji et al., ; Hu et al., ).
It is also observed that task-specific synthetic data often lacks diversity (Yu et al., ), whereas general synthetic data suffers from pattern overfitting (Chen et al., ) and the memorization of the synthesis model’s training data (Van Breugel et al., ).
Another challenge of synthetic data training is the phenomenon of model collapse (Shu et al., ), where the massive noise in unregulated synthetic
data leads to the disappearance of the tails of the original content distribution and ineffective student models (Seddik et al., ).

To address these limitations, researchers have explored various approaches to improve the utility of synthetic data (Shu et al., ; Wang et al., ). One line of work focuses on filtering out noisy synthetic data, using techniques like ranking synthetic data with an additional reward model (Shu et al., ), verifying the truthfulness of responses via programs (Dong et al., ), prompting LLMs to judge the data quality (Zheng et al., ), and ensemble of multiple teacher (Lee et al., ). One can also directly adjust the teacher’s synthesis strategies to generate more useful data for students (Lee et al., ; Yuan et al., ). For instance, LLM2LLM (Lee et al., ) collects data points that the student answers incorrectly and prompts the teacher to bootstrap similar data, thereby generating targeted data to strengthen the student’s weaknesses.
Another potential path, such as Self-Reward (Yuan et al., ), is to employ LLM-as-a-judge (Zheng et al., ) to assign each response a discrete reward score and optimize the student to generate highly rewarding responses.

The last body of related work is data influence functions (Hampel, ), a commonly used technique for measuring the utility of data on a model’s performance.
Influence function (Hampel, ; Koh & Liang, ; Bae et al., ) quantifies the change in reference loss when a data point is upweighted in the training set (Koh & Liang, ). It often serves as a theoretical tool to analyze data utility (Choe et al., ) and attribute model behavior (Park et al., ). Recent work has applied influence functions to facilitate model-aware data selection in pretraining or instruction-tuning, using first-order approximation (Xia et al., ), linear datamodels (Engstrom et al., ), and data influence models (Yu et al., ). These methods have been shown to be more effective than traditional rule-based techniques in data selection, mostly notably in the pretraining stage (Engstrom et al., ; Yu et al., ).

## 3 Montessori-Instruct

This section first introduces the overall framework of Montessori-Instruct (§ 3.1) and then elaborates its two main components: local data influence collection (§ 3.2) and student-preference-guided teacher optimization (§ 3.3).

### 3.1 Overall framework

Standard data synthesis methods (Wang et al., ; Yuan et al., ; Lee et al., ) begin with a teacher model $\mathcal{M}$ and a seed prompt $p$ formed using a few-shot sample of example data. The teacher model processes the seed $p$ to generate a set of $N$ new instructions, $\{x_{i}\mid 1\leq i\leq N\}$, that follow a similar format to the seed but with a variety of contents. Each generated instruction $x_{i}$ is then used to prompt the teacher to synthesize the corresponding response $y_{i}$.
This yields a set of instruction-response pairs $\{(x_{i},y_{i})\mid 1\leq i\leq N\}$ that are then used to train the student model $m$.

Montessori-Instruct upgrades this standard data synthesis pipeline with the optimization of the teacher model toward the student’s learning preferences.
The student-preference-guided teacher optimization starts with prompting the teacher to generate a probing dataset $\mathcal{D}_{\text{probing}}$ using Self-Instruct and then collecting these data points’ local data influence $\mathcal{I}_{m}$ on the student model (§ 3.2).
The collected data preferences form the preference dataset $\mathcal{D}_{\text{preference}}$, and Montessori-Instruct uses it to update the teacher model via Direct Preference Optimization (DPO) (Rafailov et al., ) (§ 3.3).
The optimized teacher then generates the actual training dataset to train the student model $m$.
The process can be iterated multiple rounds to continually refine the teacher according to the student’s updated preferences. This process is illustrated in Figure 2 and discussed in detail in the next two sections.

Figure: Figure 2: Student-Preference-Guided teacher optimization in Montessori-Instruct.
Refer to caption: x5.png

### 3.2 Local data influence collection

A key component of our framework is to precisely measure the utility of synthetic data, i.e., how good they are at improving the student’s learning outcomes.
This question is often approached using influence functions (Weisberg & Cook, ; Koh & Liang, ), which was designed to quantify changes in reference loss when a data point $(x_{i},y_{i})$ is upweighted in the training sets Park et al. (), thus reflecting the utility of this data point to the student’s learning.

In order to efficiently calculate the data influence, we follow Yu et al. () and approximate influence functions locally, using the change of the model’s reference loss before and after training on a single data point $(x_{i},y_{i})$:

$$ $\displaystyle\mathcal{I}_{m}(x_{i};\mathcal{D}_{\text{ref}})\approx-\mathcal{L }(\mathcal{D}_{\text{ref}}$ $\displaystyle\mid\mathcal{A}(y_{i}\mid x_{i};m))+\mathcal{L}(\mathcal{D}_{ \text{ref}}\mid m),$ (1) $\displaystyle\text{where}~{}\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m)$ $\displaystyle=\mathbb{E}_{(x,y)\sim\mathcal{D_{\text{ref}}}}\>\ell(y\mid x;m),$ (2) $$

where $\mathcal{D}_{\text{ref}}$ denotes the reference data that measure the student’s capability, and $\ell(y|x;m)$ is the loss of student $m$ on an input-output pair $(x,y)$. $\mathcal{A}(y_{i}\mid x_{i};m)$ refers to the optimization operation of student $m$ on data $(x_{i},y_{i})$, e.g., one-step training with Adam (Kingma & Ba, ) on $(x_{i},y_{i})$.

The local data influence, $\mathcal{I}_{m}(x_{i};\mathcal{D}_{\text{ref}})$, represents how the instruction-response pair $(x_{i},y_{i})$ impacts the student’s learning outcome as measured on the reference data. A positive $\mathcal{I}_{m}$ indicates that the data benefits the student’s reference performance, while a negative $\mathcal{I}_{m}$ shows the opposite. A complete theoretical derivation of local data influence is provided in Appendix B.

### 3.3 Student-Preference-Guided teacher optimization

After calculating local data influence for each instruction in the probing dataset $\mathcal{D}_{\text{probing}}$, we pair every two instructions with positive and negative influence, along with their corresponding seed prompt $p$, to construct the preference dataset:

$$ $\displaystyle\mathcal{D}_{\text{preference}}=\{(p,x^{+},x^{-})\mid\mathcal{I}_ {m}(x^{-};\mathcal{D}_{\text{ref}})<0<\mathcal{I}_{m}(x^{+};\mathcal{D}_{\text {ref}})\}.$ (3) $$

We then apply DPO to optimize the teacher model $\mathcal{M}$ toward the student’s learning preferences:

$$ $\displaystyle\mathcal{L}_{\text{DPO}}(\mathcal{M}^{*};\mathcal{M})=-\mathbb{E} _{(p,x^{+},x^{-})\sim\mathcal{D}_{\text{preference}}}[\text{ log}\sigma(\beta \text{ log}\frac{\mathcal{M}^{*}(x^{+}\mid p)}{\mathcal{M}(x^{+}\mid p)}-\beta \text{ log}\frac{\mathcal{M}^{*}(x^{-}\mid p)}{\mathcal{M}(x^{-}\mid p)})],$ (4) $$

where $\beta$ is a parameter that controls the deviation from the initial teacher $\mathcal{M}$ and $\sigma$ is the logistic function. The updated teacher, $\mathcal{M}^{*}$, after one or multiple iterations, is then used to synthesize the training data for the student model $m$.

## 4 Experimental methodologies

This section details our main experimental setups, including a thorough configuration of the data synthesis process, the chosen baselines, and the evaluation methods.

#### Data Synthesis Process.

We choose Llama3-8B-Instruct (Meta, ) as the teacher, and train Llama3-8B (Meta, ) and Tinyllama-1.1B (Zhang et al., ) as students. We merge the text in instruction and input fields of Alpaca GPT-4 dataset (Taori et al., ), consisting of 52K entries, to create our seed pool. We follow the 8-shot seed proposed in Self-Instruct (Wang et al., ) to prompt the teacher to generate instructions, with 6 out of the 8 randomly sampled from the seed pool and 2 sampled from the synthetic instructions in the teacher’s previous iterations. Detailed prompts are provided in Figure 13.

Following Yuan et al. (), we initially use the unoptimized teacher model to synthesize 1K data to warm up the student. Then, we generate 4 instructions for each seed and 1 response for each instruction and filter out similar instructions whose Rough-L score exceeds 0.7, resulting in a probing dataset of 10K prompt-instruction-response triplets. For each instruction-response pair in the probing dataset, we collect local data influence using the loss difference of the student model on the reference data (Alpaca GPT-4 (Peng et al., )) before and after one-step training. Then, we construct a preference dataset comprising 6,792 entries, where each entry represents a seed-instruction pair with positive and negative influences.
This preference dataset is used to train the teacher with Direct Preference Optimization (DPO) (Rafailov et al., ).
Finally, we use the optimized teacher to synthesize 10K data to train the student from scratch. In the subsequent iterations, we optimize the teacher using similar steps, but with the updated student from last iteration to collect data influence. The updated student is then used as the starting point to enable continuous training. For both the teacher and student training, we utilize AdamW optimizer (Loshchilov & Hutter, ) along with WSD scheduler (Hu et al., ). Both models are trained for one epoch.
For teacher’s generation, we use vLLM (Kwon et al., ) as our decoding engine and provide specific decoding parameters in Table 5. More details can be found in Appendix A.

#### Baselines.

We compare our method against several mainstream data synthesis baselines. The simplest baseline is Self-Instruct (Wang et al., ), where we use the unoptimized teacher to synthesize data. Additionally, we select GPT-4o (OpenAI, ) as a stronger teacher to synthesize an equivalent amount of data for comparison. Another baseline is Self-Reward (Yuan et al., ), which employs an LLM-as-a-judge (Zheng et al., ) to assign ratings from 1 to 5 points to its self-synthesized responses. Since we find in our preliminary experiments that Llama3-8B lacks the ability to effectively score its own responses, we instead employ GPT-4o as an external judge to score the student’s responses. The results of the original Self-Reward are reported in the Appendix § D.3. The final baseline is LLM2LLM (Lee et al., ), which evaluates the student’s accuracy on its seed set and filters out those that result in incorrect answers.
In our case, we define data points with the highest 50% training loss as incorrect examples.
The teacher is then prompted to bootstrap data similar to the incorrectly answered seeds. To align with our setting, we uniformly conduct two rounds of iterations for Self-Reward and LLM2LLM. For all methods, we synthesize 10K instruction-response pairs to train the student models.

#### Evaluation Methods.

We use Alpaca Eval 2.0 (Dubois et al., ) as the in-domain evaluation to assess the model’s instruction-following ability. We utilize gpt-4-turbo-2024-04-09 as the evaluator and uniformly compare all methods against the student model trained with Self-Instruct. The evaluation metrics are standard Winng Rate (WR) and Length Control Winning Rate (LC-WR). For head-to-head winning rate, we employ the evaluation prompt in both pairwise orders, and if the results disagree, we count it as a tie.
Additionally, we evaluate the model’s generalization performance across six out-of-domain tasks, including MT-Bench (Zheng et al., ), ARC-Challenge (25-shot) (Clark et al., ), GSM8K (8-shot) (Cobbe et al., ), HellaSwag (8-shot) (Zellers et al., ), GPQA (0-shot) (Rein et al., ), and MMLU (0-shot) (Hendrycks et al., ). These tasks span areas such as multi-turn dialogue, knowledge-based question answering, mathematics, and natural language reasoning, offering a thorough assessment of our approach’s effectiveness. For MT-Bench, we report the score out of 10 judged by gpt-4-turbo-2024-04-09. For other tasks, we report normalized accuracy if it is included in the evaluation results, otherwise, standard accuracy.

## 5 Evaluation results

This section evaluates the effectiveness of Montessori-Instruct (§ 5.1), illustrates the correlation between the teacher’s learning and the student’s performance (§ 5.2), conducts comprehensive ablation studies on the effectiveness of local data influence, the optimization of the teacher, the seed data and multiple iterations (§ 5.3), and then demonstrates the generalization of the synthetic data from Montessori-Instruct (§ 5.4).

### 5.1 Overall performance

**Table 1: Evaluation of training 8B/1.1B students with different data synthesis methods. Adoption of a stronger teacher model (GPT-4o) is indicated by $*$. All else use Llama3-8B-Instruct as the teacher model. The best and second-best performances are marked in bold and underscore, respectively.**
|  | In-Domain | Out-Of-Domain |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | Alpaca Eval 2.0 | MT-Bench | MMLU | GPQA | ARC-C | GSM8K | HellaSwag |  |
| LC-WR | WR | Score | Accuracy |  |  |  |  |  |
| 8B Setting: Student=Llama3-8B |  |  |  |  |  |  |  |  |
| No fine-tuning | 2.09% | 3.39% | 5.597 | 62.15 | 24.33 | 57.85 | 51.25 | 81.96 |
| Self-Instruct | 50% | 50% | 6.490 | 62.42 | 31.92 | 59.98 | 58.76 | 80.93 |
| Self-Instruct^∗ | 54.95% | 56.39% | 5.918 | 63.41 | 30.13 | 60.58 | 50.42 | 81.42 |
| Self-Reward^∗ |  |  |  |  |  |  |  |  |
| Iteration 1 | 51.87% | 55.38% | 6.713 | 62.46 | 28.19 | 59.84 | 53.60 | 81 .04 |
| Iteration 2 | 53.49% | 57.32% | 6.798 | 62.02 | 29.08 | 60.64 | 56.37 | 81.13 |
| LLM2LLM |  |  |  |  |  |  |  |  |
| Iteration 1 | 51.49% | 53.12% | 6.531 | 62.18 | 29.12 | 57.49 | 55.28 | 80.49 |
| Iteration 2 | 52.63% | 55.02% | 6.519 | 62.46 | 30.04 | 59.65 | 57.75 | 80.57 |
| Montessori-Instruct |  |  |  |  |  |  |  |  |
| Iteration 1 | 54.92% | 58.59% | 6.903 | 62.93 | 29.91 | 62.97 | 58.76 | 81.22 |
| Iteration 2 | 56.82% | 60.23% | 7.092 | 63.44 | 31.19 | 59.98 | 60.05 | 81.98 |
| 1.1B Setting: Student=Tinyllama-1.1B |  |  |  |  |  |  |  |  |
| No fine-tuning | 17.89% | 17.56% | 1.020 | 26.16 | 23.88 | 37.12 | 1.97 | 62.61 |
| Self-Instruct | 50% | 50% | 2.154 | 26.21 | 24.78 | 37.97 | 1.82 | 62.47 |
| Self-Instruct^∗ | 54.02% | 55.02% | 1.928 | 26.64 | 24.33 | 38.82 | 2.20 | 63.17 |
| Self-Reward^∗ |  |  |  |  |  |  |  |  |
| Iteration 1 | 47.62% | 48.34% | 1.804 | 26.34 | 23.92 | 37.64 | 1.76 | 62.27 |
| Iteration 2 | 46.48% | 46.95% | 1.717 | 26.09 | 24.62 | 38.03 | 1.76 | 62.79 |
| LLM2LLM |  |  |  |  |  |  |  |  |
| Iteration 1 | 52.03% | 52.75% | 2.243 | 25.87 | 24.51 | 36.86 | 2.24 | 62.15 |
| Iteration 2 | 51.64% | 53.52% | 2.192 | 25.62 | 24.84 | 36.74 | 2.31 | 62.08 |
| Montessori-Instruct |  |  |  |  |  |  |  |  |
| Iteration 1 | 53.25% | 51.77% | 2.485 | 26.23 | 23.92 | 37.97 | 2.35 | 62.59 |
| Iteration 2 | 54.52% | 54.97% | 2.504 | 26.35 | 24.88 | 38.11 | 2.91 | 63.55 |

Table 1 presents the overall performance of Montessori-Instruct compared with the state-of-the-art data synthesis methods.
In the 8B setting, Montessori-Instruct significantly outperforms Self-Instruct by 6.37% LC-WR and 10.15% WR on Alpaca Eval. Notably, our method still surpasses Self-Instruct with GPT-4o as the teacher, suggesting that a stronger LLM does not necessarily produce more beneficial data than a weaker LLM that is tailored to the student’s needs.
Compared to Self-Reward and LLM2LLM, Montessori-Instruct consistently shows better performance across both iterations. This underscores the advantage of directly optimizing the teacher model’s parameters toward the student’s preferences derived from data influence.

In addition to in-domain evaluation, Montessori-Instruct also outperforms all the baselines on out-of-domain tasks, achieving maximum improvements of 0.673 and 0.372 on the MT-Bench in the 8B and 1.1B settings, respectively. This indicates that the teacher optimized by our method does not overfit the reference tasks and maintains strong robustness and generalization capabilities, whereas other baselines suffer from performance degradation on out-of-domain tasks.

### 5.2 Correlation between teacher’s learning and student’s performance

This set of experiments examines how the teacher is progressively optimized to align with student preferences, thereby enhancing the student’s performance.
We first zoom in on the teacher’s learning process to investigate its progressive impact on student models. Figures 3(a) and 3(b) compare the performance of students trained using synthetic data generated from the teacher’s intermediate checkpoints. The learning margin reflects the teacher’s learning process, representing the average difference between selected rewards and corresponding rejected rewards in DPO. A larger margin indicates that the teacher is more likely to generate the selected synthetic data. The results indicate a positive correlation between the student’s performance and the teacher’s optimization progress.

We then select several teacher checkpoints to examine the properties of their synthetic data, aiming to identify changes occurring as the teacher learns. Specifically, we focus on the distribution of local data influence in the synthetic data, defined as the change in the model’s reference loss before and after training on a single data point, which indicates the utility of that data for the model. The baseline reference loss is the loss on the reference set prior to one-step training, i.e., Equation 2. As shown in Figure 3(c), we observe that as the teacher is optimized, the distribution of its synthetic data shifts towards the positive side, indicating an increased proportion of data with positive local influence in its synthetic outputs. From the student’s perspective (Figure 3(d)), which shows the changes in the proportion of data with positive local influence in the next training batch, this proportion decreases over time during training. However, the data generated by the updated teacher consistently maintains a higher proportion of positive influence compared to a regular teacher.

In summary, we attribute the improved performance achieved by Montessori-Instruct to the teacher’s continuously enhanced ability to synthesize data with higher local influence, by using DPO to distinguish data with varying influence values. The positive correlation between student performance and the increased proportion of training data with positive local influence leads to more effective learning, thereby improving the student’s overall performance.

Figure: (a) Alpaca Eval
Refer to caption: x6.png

### 5.3 Ablation studies

**Table 2: Ablation studies on the effectiveness of the methodological design in Montessori-Instruct. All experiments were conducted on the Llama3-8B students.**
| Methodological design | Alpaca Eval 2.0 | MT-Bench | MMLU | GPQA | ARC-C | GSM8K | HellaSwag |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LC-WR | WR | Score | Accuracy |  |  |  |  |  |
| Effectiveness of Local Data Influence |  |  |  |  |  |  |  |  |
| LLM-as-a-Judge | 53.42% | 54.93% | 6.731 | 62.93 | 29.75 | 62.09 | 58.82 | 81.05 |
| Training loss | 52.34% | 54.99% | 6.656 | 62.54 | 29.89 | 61.48 | 58.76 | 80.93 |
| Local data influence (Ours) | 54.92% | 58.59% | 6.903 | 62.93 | 29.91 | 62.97 | 58.76 | 81.22 |
| Effectiveness of Teacher Optimization |  |  |  |  |  |  |  |  |
| Bootstrap | 50.59% | 48.14% | 6.618 | 60.67 | 25.19 | 57.95 | 58.13 | 80.46 |
| Response optimization | 51.59% | 54.22% | 6.556 | 62.43 | 27.45 | 60.42 | 56.38 | 81.04 |
| Instruction optimization (Ours) | 54.92% | 58.59% | 6.903 | 62.93 | 29.91 | 62.97 | 58.76 | 81.22 |
| Effectiveness of Seed Data |  |  |  |  |  |  |  |  |
| Open Assistant (OOD) | 52.28% | 54.76% | 6.706 | 62.86 | 29.74 | 62.29 | 58.42 | 81.24 |
| Alpaca GPT4 (ID) (Ours) | 54.92% | 58.59% | 6.903 | 62.93 | 29.91 | 62.97 | 58.76 | 81.22 |
| Alpaca Eval (Test) | 57.64% | 61.36% | 7.147 | 62.93 | 30.44 | 63.06 | 60.80 | 81.09 |

This subsection demonstrates the effectiveness of the methodological design in Montessori-Instruct through four ablation studies, summarized in Table 2. The yellow lines show ablations on data point utility evaluation methods. The red lines represent optimization for responses based on instructions and optimization for teacher models. The blue lines cover various seed data types: OOD (Out-Of-Domain), ID (In-Domain), and Test (direct use of the test set).

#### Effectiveness of Local Data Influence.

To evaluate the impact of different methods for obtaining the influence of a data point, we compare our local data influence against two additional baselines: (1) LLM-as-a-Judge (Zheng et al., ), which leverages GPT-4o to directly assign a 1-5 score to each instruction-response pair, inspired by Self-Reward, and (2) Training loss, which directly uses the training loss of each data point as its influence score, inspired by LLM2LLM. As shown in the yellow lines in table 2, our local data influence consistently outperforms both baselines by a significant margin. This indicates that local data influence is a more effective metric for capturing students’ fine-grained data preferences compared to the other methods.

#### Effectiveness of Teacher Optimization.

To analyze the effectiveness of the optimization strategy on the teacher, we compare our method with two additional ablation baselines: (1) Bootstrap: we bootstrap the top 50% influential data by utilizing it as the seed, and (2) Response optimization: we optimize the teacher by the student’s local data influence of different responses given an instruction.
As shown in red lines in table 2, optimizing the teacher is generally better than merely bootstrapping influential data, highlighting the necessity of adapting the teacher to the student’s needs. Furthermore, instruction optimization (Montessori-Instruct) outperforms response optimization across all tasks. We attribute this to the smaller search space of response optimization, which limits the headroom for teacher improvement compared to instruction optimization.

#### Effectiveness of Seed Data.

This study examines the impact of the seed data by varying its relevance to the evaluation tasks.
In addition to the Alpaca GPT-4 (in-domain seed data) used in the main experiments, we also utilize Open Assistant and Alpaca Eval as alternative seed data. Open Assistant represents an out-of-domain seed, whereas Alpaca Eval is directly sampled from the evaluation task.
Blue lines in table 2 demonstrates that using Alpaca Eval leads to the best performance on itself while using Open Assistant is less effective compared to in-domain seed data. For more general NLP benchmarks, changing the seed data results in only slight differences in performance. This indicates that our method is robust enough to enhance the synthesis ability of teachers, even when using different seeds.

#### Effectiveness of Multiple Iterations.

We examine the performance differences when applying Montessori-Instruct over multiple iterations. In each iteration, we begin by constructing a probing dataset of 2K samples to collect local data influence on the student model from the previous iteration, followed by updating the previous teacher. As shown in Figure 4, Montessori-Instruct continues to outperform Self-Instruct across three iterations, achieving a peak head-to-head win rates of 51.9%. The results in Figure 4 illustrate the comparison between different iterations, demonstrating that Montessori-Instruct can yield improvements over previous iterations. We attribute these gains to the Montessori-Instruct’s ability to capture the data preferences of students at different iterations and to tailor influential data according to their evolving needs.

Figure: Figure 4: Head-to-head win rates for evaluating 8B models among the Self-Instruct baseline and three successive iterations updated using Montessori-Instruct. Left: Win rates of iterations compared to Self-Instruct; Right: Win rates compared between different iterations.
Refer to caption: x10.png

### 5.4 Generalization ability of the synthesized data

Figure: (a) Llama3-8B
Refer to caption: x11.png

In this experiment, we study the generalization ability of our teacher optimized toward a small student (1.1B)’s preferences.
Specifically, we utilize the data synthesized by this teacher to train four different student models—Llama3-8B (Meta, ), Mistral-7B (Jiang et al., ), Qwen1.5-7B (Bai et al., ), and Gemma2-9B (Team et al., ). As shown in Figure 5, the data synthesized by one teacher leads to consistent performance gains across all the students compared to Self-Instruct. This finding implies we can directly deploy an optimized teacher to generate data for a variety of student models, enhancing their performance with a low expense.

Figure: (a) Self-Instruct
Refer to caption: x15.png

### 5.5 Case study

In this section, we present several cases to visualize the differences between the instructions synthesized by Self-Instruct and by Montessori-Instruct, and showcase the chosen and rejected data pairs that reflect what the teacher learns during our optimization. Figure 6 shows the word analysis of root verbs and their corresponding nouns. We identify the top 10 most common root verbs (inner circle) and their top 4 direct noun objects (outer circle) in the generated instructions. The results indicate that, compared to Self-Instruct, Montessori-Instruct guides the teacher to synthesize more on writing instructions and providing specific, informative examples, while reducing the frequency of simple commands like summarizing and translating.

Table 3 compares the chosen and rejected data pairs given the same prompt. Our method discards low-utility data, such as explanations of simple concepts and sentence translations, and increases the likelihood of generating complex and informative instructions. This further demonstrates the effectiveness of using local data influence to differentiate data utility.

**Table 3: Examples of instruction-response pairs with positive and negative influences under the same prompt**
| Positive | Negative |
| --- | --- |
| [Instruction]: What is the most efficient way to transport a given package across a city, considering traffic congestion, distance, and cost?<br>[Response]: The most efficient way to transport a package across a city depends on several factors, including the package’s size, weight, fragility, and urgency, as well as the city’s traffic patterns, infrastructure, and regulations. Here are some general considerations and options to minimize costs, reduce congestion, and ensure timely delivery:<br>1. **Distance and Route Optimization**:<br>* Use online route planners or transportation management software to determine the shortest and most efficient route.<br>* Consider alternative routes or modes of transportation if the primary route is congested or closed.<br>2. **Traffic Congestion Mitigation**:<br>* Avoid peak hours (7-9 am and 4-6 pm) when possible, as traffic congestion is typically highest during these times… | [Instruction]: Explain the concept of artificial intelligence in 100 words.<br>[Response]: Artificial intelligence (AI) refers to the development of computer systems that can perform tasks that typically require human intelligence, such as learning, problem-solving, and decision-making. AI systems use algorithms and data to analyze and interpret information, allowing them to make predictions, classify objects, and generate insights. They can be trained on large datasets to improve their performance over time, and can even adapt to new situations and learn from experience. AI has many applications, including robotics, natural language processing, image recognition, and expert systems, and is increasingly being used in industries such as healthcare, finance, and transportation. |
| [Instruction]: Can you write a script for a public service announcement about the importance of recycling?<br>[Response]: Here is a script for a public service announcement about the importance of recycling:<br>[Opening shot of a beautiful park or nature reserve, with a narrator speaking]<br>Narrator: ”Imagine a world where our planet is thriving, where wildlife roams free, and where our communities are healthy and strong. But to get there, we need to take action.”<br>[Cut to a shot of a person holding a plastic bottle and throwing it away]<br>Narrator: ”One of the simplest and most effective ways to make a difference is by recycling.”… | [Instruction]: Can you translate the following text from english to spanish: ”the hotel room was comfortable and clean.”<br>[Response]: The translation of the text from English to Spanish is:<br>”El cuarto de hotel era cómodo y limpio.”<br>Here’s a breakdown of the translation:<br>* ”the hotel room” = ”el cuarto de hotel”<br>* ”was” = ”era” (verb conjugation)<br>* ”comfortable” = ”cómodo”<br>* ”and” = ”y” (conjunction)<br>* ”clean” = ”limpio”<br>So, the complete sentence in Spanish is: ”El cuarto de hotel era cómodo y limpio.” |

## 6 Discussion and limitations

#### Synthetic Data Scale.

We synthesize 10K data points to verify the effectiveness of our innovative data synthesis framework. While this 10K dataset outperforms other baselines and demonstrates strong generalization, its effectiveness when scaled to the volume required for production-level fine-tuning (around 100K) remains unclear. Expanding the synthetic data volume may introduce redundancy, a phenomenon commonly observed in data synthesis (Bauer et al., ; Liu et al., ). It would be meaningful to study how to balance the quantity and the diversity of the synthetic data, while this is orthogonal to our main contribution.

#### Overhead.

Montessori-Instruct introduces an additional computational cost. Compared to Wang et al. (), training an 8B model using our method increases the average processing time per data by 5.8 seconds (see the Appendix E for details). At the instruction finetuning stage, compute is less an issue compared to pretraining. The scale is smaller, and generating data is faster and cheaper than human annotations. Additionally, the most time-intensive step in our method–”collecting local data influence”–can be independently parallelized on heterogeneous compute systems, allowing for easy acceleration. As demonstrated in § 5.4, Montessori-Instruct exhibits strong generalization capabilities. In practice, one can use a smaller model to collect data influence for updating the teacher and then apply the updated teacher to synthesize data for larger models.

## 7 Conclusion

In this paper, we propose Montessori-Instruct, a novel data synthesis framework that tailors the teacher for student learning. Montessori-Instruct leverages local data influence to reflect the student’s learning preferences and to optimize the teacher to produce more influential synthetic training data. Experimental results demonstrate that Montessori-Instruct significantly outperforms state-of-the-art data synthesis methods in both in-domain and out-of-domain evaluations, exceeding the performance of data generated by stronger teacher models like GPT-4o. Further analyses confirm the benefits of optimizing the teacher toward the student’s preferences in improving student performances. Ablation studies validate the benefits of using local data influence to reflect data utility and highlight the benefits of optimizing the teacher over bootstrapping. Our work successfully demonstrates the potential of incorporating the student’s learning preferences into teacher optimization, and we hope it inspires further exploration of more effective synthetic data generation frameworks.

## Acknowledgements

We thank Zhenghao Liu, Shi Yu, Wentao Shi, Cathy Jiao, Joao Coelho, Gbemileke Onilude, Gary Gao and Alex Xu for their helpful feedback on this work.

## Appendix A Training details

The hyperparameters used during training teachers and students are as follows. We employ the AdamW optimizer (Loshchilov & Hutter, ) with a WSD scheduler (Hu et al., ). For SFT, the 8B model utilizes a maximum learning rate of $5e^{-6}$, while the 1B model uses $1e^{-5}$. The WSD scheduler is configured with a warmup ratio of $0.1$, a stable ratio of $0.5$, and a decay ratio of $0.4$, with the learning rate decaying to one-thousandth of the maximum. The epoch is set to $1$, batch size is set to $32$ and the dropout is 0 0. We mask non-target tokens, calculating the loss only on target tokens. If the student model does not have a chat template itself, we apply the Llama3-8B formatted chat template, as shown in 7, with bos_token, eos_token and pad_token set to

, 
, and 
, respectively. For DPO, we use a learning rate of $1e^{-6}$, set $\beta$ to $0.1$, and use a batch size of $2$, while other parameters remain the same as in SFT.

Figure: Figure 7: Chat Template

We use Hugging Face TRL codebase (von Werra et al., ) to perform both full parameters fine-tuning and direct preference optimization. For the 8B model, we employ the Hugging Face Accelerate codebase (Gugger et al., ) to facilitate FSDP training (Zhao et al., ). All the parameters introduced in this section are summarized in Table 4.

**Table 4: Training Parameters**
| Method | Learning Rate | Weight Decay | Warmup Ratio | Stable Ratio | Decay Ratio |
| --- | --- | --- | --- | --- | --- |
| SFT | $5.0e-6$ | $0.0$ | 0.1 | 0.5 | 0.4 |
| DPO | $1.0e-6$ | $0.0$ | 0.1 | 0.5 | 0.4 |
| Method | Minium Learning Rate | Epoch | Per Device Train Batch Size | Gradient Accumulation | Train Batch Size |
| SFT | $5.0e-9$ | $1$ | $2$ | $2$ | $32$ |
| DPO | $1.0e-9$ | $1$ | $2$ | $1$ | $2$ |
| Method | Max Length | Dropout | BF16 | Flash Attention 2 | Beta |
| SFT | $1024$ | $0.0$ | True | True | - |
| DPO | $1024$ | $0.0$ | True | True | $0.1$ |

## Appendix B Theoretical guarantee of local data influence

This section provides a detailed explanation of the derivation for computing local data influence and the rationale behind its effectiveness. We referred to the derivation method in Yu et al. (). We use $\mathcal{D}_{\text{ref}}$ to represent the reference set and $m$ to represent the student model that we calculate local data influence on. The derivation begins with the standard influence functions Koh & Liang (); Weisberg & Cook () which quantify the change in reference loss when a data point $x_{i}$ is upweighted by a small $\epsilon$. We denote the optimal model state after the upweighting as $m_{\epsilon,x_{i}}=\mathop{\arg\min}_{m}\frac{1}{n}\sum_{j=1}^{n}\mathcal{L}(x
_{j}\mid m)+\epsilon\mathcal{L}(x_{i}\mid m)$ and simplify the optimal model under $\epsilon=0$ case (i.e., no upweighting) as $m$. The influence of upweighting $x_{i}$ is then given by:

$$ $\displaystyle\mathcal{I}_{m}(x_{i};\mathcal{D}_{\text{ref}})$ $\displaystyle\stackrel{{\scriptstyle\mathclap{\mbox{def}}}}{{=}}\frac{d \mathcal{L}(\mathcal{D}_{\text{ref}}\mid m_{\epsilon,x_{i}})}{d\epsilon}|_{ \epsilon=0}$ (5) $\displaystyle=\nabla_{m}\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m)^{\top} \frac{dm_{\epsilon,x_{i}}}{d\epsilon}|_{\epsilon=0}$ (6) $\displaystyle=-\nabla_{m}\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m)^{\top}H_{ m}^{-1}\nabla_{m}\mathcal{L}(x_{i}\mid m),$ (7) $$

where $H_{m}=\frac{1}{n}\sum_{j=1}^{n}\nabla^{2}_{m}\mathcal{L}(x_{j}\mid m)$ is the Hessian matrix, which is positive definite. The derivation from Eq. 6 to Eq. 7 is given by building a quadratic approximation to the empirical risk around $m$ and tperforming a single Newton step as shown in Koh & Liang (). Now let’s consider the scenario in which $x_{i}$ is incorporated into the training data. In this case, $\epsilon=\frac{1}{n}$, and the parameter difference due to the inclusion of $x_{i}$ is $m_{\frac{1}{n},x_{i}}-m\approx\frac{1}{n}H_{m}^{-1}\nabla_{m}\mathcal{L}(x_{i}
\mid m)$ and the influence in Eq. 7 can be further represented as:

$$ $\displaystyle\mathcal{I}_{m}(x_{i};\mathcal{D}_{\text{ref}})$ $\displaystyle\approx-n\nabla_{m}\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m)^{ \top}(m_{\frac{1}{n},x_{i}}-m)$ (8) $\displaystyle\approx-n(\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m_{\frac{1}{n} ,x_{i}})-\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m))$ (9) $\displaystyle\propto-\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m_{\frac{1}{n},x _{i}})+\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m).$ (10) $$

So far, we have successfully derived the method (Eq. 10) of calculating local data influence used in § 3.2. Using the supervised fine-tuning algorithm $\mathcal{A}$, we denote the model state $m_{\frac{1}{n},x_{i}}$ as $\mathcal{A}(y_{i}\mid x_{i};m)$, which is updated on the synthetic data point $(x_{i},y_{i})$ for one step. Replacing the variables in Eq. 10 with the notation of our method, we can obtain:

$$ $\displaystyle\mathcal{I}_{m}(x_{i};\mathcal{D}_{\text{ref}})\approx-$ $\displaystyle\mathcal{L}(\mathcal{D}_{\text{ref}}\mid\mathcal{A}(y_{i}\mid x_{ i};m))+\mathcal{L}(\mathcal{D}_{\text{ref}}\mid m)$ (11) $$

## Appendix C Statistics on synthesis data

We plot the top 20 most common root verbs (inner circle) and their top 4 direct noun objects (outer circle) in the generated instructions by Self-Instruct (Figure  8), the first iteration of Montessori-Instruct (Figure  9), and the second iteration of Montessori-Instruct (Figure  10), respectively.

We observe an increasing trend in instructions such as ’write,’ ’provide,’ and ’make,’ as well as a consistent trend for instructions like ’explain’ and ’describe.’ These commands typically require more general detailed information and lead to longer, more complex responses. Meanwhile, commands like ’translate’ and ’calculate’ show a decline, as they usually require straightforward answers and simpler formats. This outcome demonstrates that Montessori-Instruct helps the teacher model generate more detailed and informative instructions, thereby improving student performance.

We also plot the distribution of tokenized instructions and responses generated by Self-Instruct and Montessori-Instruct for comparison. As shown in Figures  11(b) and  12(b), there is an increasing trend in the length of instructions, while the length of responses remains relatively unchanged. This aligns with our design, which focuses on optimizing instructions based on prompts rather than optimizing responses based on instructions. The increased length of instructions also reflects the teacher’s data synthesis strategy shifting toward more complex and informative instructions.

Figure: Figure 8: The top 20 most common root verbs (inner circle) and their top 4 direct noun objects (outer circle) in the generated instructions by Self-Instruct
Refer to caption: x17.png

Figure: Figure 9: The top 20 most common root verbs (inner circle) and their top 4 direct noun objects (outer circle) in the generated instructions by Montessori-Instruct (iteration 1)
Refer to caption: x18.png

Figure: Figure 10: The top 20 most common root verbs (inner circle) and their top 4 direct noun objects (outer circle) in the generated instructions by Montessori-Instruct (iteration 2)
Refer to caption: x19.png

Figure: Figure 11: Distribution of tokenized instructions generated by Self-Instruct and Montessori-Instruct
Refer to caption: x20.png

Figure: Figure 12: Distribution of tokenized responses generated by Self-Instruct and Montessori-Instruct
Refer to caption: x22.png

## Appendix D Additional experimental details

### D.1 Prompts used for instruction generation.

In this section, we present the prompts used in Montessori-Instruct. Figure 13 illustrates how we prompt the teacher model to generate new instructions. We begin by outlining some requirements for the teacher, followed by inserting 8-shot seed examples sampled from both the seed pool and the data pool generated in the previous iteration. We then extract the instruction from the teacher’s output using regex matching and filter out those with incorrect formats.

Figure 14 displays the prompt used in our ablation studies on the effectiveness of Local Data Influence. In this study, we evaluated different methods for assessing the utility of synthetic data, one of which involved using LLM-as-a-Judge (Zheng et al., ). We adapted the prompt from Self-Reward (Yuan et al., ) and added an additional point to evaluate the quality of the instruction, resulting in a maximum score of 6 points.

Figure: Figure 13: Prompt for Generating Instructions

Figure: Figure 14: LLM-as-a-Judge Prompt for evaluating instructions and corresponding responses in our ablation studies on the effectiveness of Local Data Influence

### D.2 Decoding strategies

We list all the parameters used for decoding outputs from language models in Table 5. Separate parameters are used for generating instructions and responses. A higher temperature is used for instruction generation to encourage diversity, enabling us to leverage local data influence to identify more informative instructions. For responses, we use a temperature of 0.6 to reduce uncertainty. Additionally, two penalty techniques are employed to mitigate duplication issues during synthesis.

**Table 5: Decoding Parameters using vLLM**
|  | Generate Instruction | Generate Responses |
| --- | --- | --- |
| temperature | 1 | 0.6 |
| top_p | 0.9 | 0.9 |
| frequency_penalty | 0 | 0 |
| presence_penalty | 1 | 1 |
| repetition_penalty | 1.5 | 1 |
| max_token | 1024 | 1024 |

### D.3 Self-Reward Results without the External Judge

In this section, we report the results of the original Self-Reward (Yuan et al., ) method. Self-Reward requires the student model to generate responses to given instructions, and then assess their own responses by generating judgments and scores ranging from 1 to 5 using LLM-as-a-Judge (Zheng et al., ). It then employs Direct Preference Optimization (DPO) to encourage the student to synthesize higher-scoring responses. However, this approach demands a high level of instruction-following ability from the student model. The authors of Self-Reward employ Llama2-70B as the student model for this reason. In our experimental setup with Llama3-8B and TinyLlama-1.1B, both models lack sufficient instruction-following capabilities and fail to produce detailed judgments and valid scores. For example, Llama3-8B’s scores are skewed, clustering around 4 and 5, making it difficult to differentiate between responses. The 1.1B model’s scores even do not follow the rules in the prompt and fall outside the specified 1 to 5 range. Therefore, in our main experiment, we use GPT-4o as an external judge to score the student responses. Nonetheless, we also report results here based on the original Self-Reward settings, where the model judges its own responses without relying on a more powerful external model.

**Table 6: Evaluation of training 8B/1.1B students using the original Self-Reward settings compared to Self-Instruct, without relying on external judges.**
|  | In-Domain | Out-Of-Domain |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | Alpaca Eval 2.0 | MT-Bench | MMLU | GPQA | ARC-C | GSM8K | HellaSwag |  |
| LC-WR | WR | Score | Accuracy |  |  |  |  |  |
| 8B Setting: Student=Llama3-8B |  |  |  |  |  |  |  |  |
| No fine-tuning | 2.09% | 3.39% | 5.597 | 62.15 | 24.33 | 57.85 | 51.25 | 81.96 |
| Self-Instruct | 50% | 50% | 6.490 | 62.42 | 31.92 | 59.98 | 58.76 | 80.93 |
| Self-Reward |  |  |  |  |  |  |  |  |
| Iteration 1 | 2.45% | 4.06% | 5.442 | 61.79 | 24.30 | 57.81 | 49.92 | 80.75 |
| Iteration 2 | 2.69% | 4.71% | 5.428 | 61.79 | 23.58 | 57.64 | 49.53 | 80.17 |
| 1.1B Setting: Student=Tinyllama-1.1B |  |  |  |  |  |  |  |  |
| No fine-tuning | 17.89% | 17.56% | 1.020 | 26.16 | 23.88 | 37.12 | 1.97 | 62.61 |
| Self-Instruct | 50% | 50% | 2.154 | 26.21 | 24.78 | 37.97 | 1.82 | 62.47 |
| Self-Reward |  |  |  |  |  |  |  |  |
| Iteration 1 | 7.79% | 8.13% | 1.000 | 23.58 | 22.30 | 36.55 | 0.94 | 61.92 |
| Iteration 2 | 6.34% | 7.57% | 1.000 | 23.44 | 22.06 | 36.49 | 0.98 | 61.24 |

## Appendix E Time overload

Compared to Self-Instruct (Wang et al., ), our method introduces additional overhead in: (1) collecting local data influence to construct the preference dataset (§ 3.2), (2) and performing DPO optimization for the teacher model (§ 3.3).
The majority of the computational overhead arises from collecting local data influence. This process begins by generating instructions and responses to create a probing dataset, distinct from the training set used for fine-tuning the student, and used solely for calculating local data influence. Then, we traverse the entire probing dataset, fine-tuning the student model on each individual data point to collect its corresponding local influence. For each data point, loading the student’s warmed-up checkpoint from disk, training for one step, and evaluating on the reference dataset are the primary time-consuming steps. We provide a detailed breakdown of the time required for these steps in table  7 and calculate the average time needed to run the entire Montessori-Instruct process and resulte in the final student model. The calculations are based on a probing dataset and training dataset, each consisting of 10K entries.

However, there are two simple ways to reduce the time demand for Montessori-Instruct. First, the process of collecting local data influence can be parallelized independently on a heterogeneous compute system to speed up execution, with no need for communication between systems—a common bottleneck in distributed training. In our experiments, we utilize 8 H100 GPUs to accelerate this process. Second, as demonstrated in our experiments (§ 5.4), Montessori-Instruct shows strong generalization capabilities. In practice, a smaller model can be used to collect data influence for updating the teacher, which can then synthesize data for larger models. This approach significantly reduces the computational overhead compared to using larger models directly for collecting local data influence.

**Table 7: Time Overload Statistics**
| Task | Sub task | 8B | 1B |
| --- | --- | --- | --- |
| collect local data influence / per data | generate instructions | 0.372s |  |
| generate responses | 0.031s |  |  |
| load warmuped ckpt from disk | 2.69s | 1.08s |  |
| fine-tune for one step | 4.12s | 0.79s |  |
| eval on reference set | 4.19s | 1.26s |  |
| total | 13.403s | 3.533s |  |
| Task | 8B | 1B |  |
| Time for DPO Training / per data | 0.362s |  |  |
| Task | Method | 8B | 1B |
| Time for obtaining the final student model / per data | Self-Instruct | 0.486s | 0.422s |
| Montessori-Instruct | 5.842s | 1.834s |  |

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: See weaknesses above
soundness: 3
strengths: * The concept of aligning the teacher model to better match the student model’s learning preferences is well-motivated.

* The method of assessing the impact of individual data points on student learning (i.e., local data influence) is a interesting approach backed by theoretical guarantees.
summary: This paper introduces Montessori-Instruct, a new framework for generating synthetic training data to enhance the learning of student language models. The authors propose a method that aligns data synthesis by a teacher model (e.g., Llama3-8B-Instruct) with the learning process of the student model (e.g., Llama3-8B). The approach involves assessing the local data influence of synthetic data points on the student model to understand its learning preferences, followed by training the teacher model using Direct Preference Optimization (DPO) to generate data better suited for the student. Experiments show that Montessori-Instruct significantly improves performance on benchmarks like Alpaca Eval and MT-Bench.
weaknesses: * Including experiments with multiple runs and reporting the mean and standard deviation would strengthen the reliability of the results.

* The performance gains, particularly on out-of-domain benchmarks, appear minimal when weighed against the additional computational cost involved in training the teacher model.

* The idea of local data influence, which is the crucial algorithm for the proposed solution, is not new but taken from a previous paper, as the authors have mentioned. This reliance on existing techniques may reduce the perceived originality of the paper.

---

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: See the weakness section.
soundness: 3
strengths: This paper proposes a synthetic data generation pipeline to customizedly align the expert model towards higher data utility over the student model. Specifically, 
+ the method proposed is sound and can intuitively address the OOD issue with the synthetic data to enhance the generalizability of the student model.
+ this paper has good presentations and conveys the idea clearly.
summary: This paper proposes a customized synthetic data generation pipeline that seeks to improve the expert model towards generating more useful and debiased data for the student model by aligning the expert model towards data distribution with higher influences on the student model via DPO. Specifically, this paper (1) first adopts an established influence function in active learning to measure the utility of a single data point in the probing set, (2) then they construct preference data using the positive and negative data influences sampled from a same prompt, and use this data to align the expert model. Finally, they regenerate data from the updated expert model and finetune the student model with this data. While the method proposed in this paper generally make sense, it suffers from a lack of ablation study and analysis on the additional cost (e.g. manual curation cost of the reference set, per sample influence inference cost, training cost of DPO on expert model) incurred by this data selection process.
weaknesses: The paper lacks more informative ablation study and in-depth explanation and analysis, especially,
+ How do the authors pick the reference dataset and determine its size? It seems this dataset is critical to judge the influence of the data samples on the student model and highly determine the performance of the fine-tuned student model later. 
+ Can the author provide some ablation study on the size of the reference dataset and its selection method?
+ How many samples do the authors obtain for each prompt in order to get a pair of positive and negative instruction? What are the additional costs behind these?
+ Calculating the inference for each data point in the probing set seems a bit costly as it involves an LLM optimization (even if just one step). Can the authors provide an ablation study on the sample size of the probing set and the final performance?
+ It also introduces some other additional costs as the proposed method involves DPO on the expert model, while most of the baselines do not. As the expert model is large in size, this training cost seems also non-negligible.

---

confidence: 4
contribution: 4
initial_rating: 6
presentation: 3
questions: - In lines 226-228, how were the 6,792 preference pairs collected from the 10K probing dataset?
- Will the general capabilities of the optimized teacher model deteriorate?
soundness: 3
strengths: - A novel data influence-driven approach where the teacher model actively learns to generate training data by optimizing against student's learning preferences, in contrast to previous works that use a static teacher.
- The experimental comparisons and benchmarks are comprehensive, the proposed method shows significant improvements, and the ablation and analysis experiments are thorough.
summary: This paper introduces Montessori-Instruct, a novel framework that optimizes the teacher model's data generation capabilities by aligning them with student learning preferences. The framework uses local data influence measurements to estimate how synthetic data impacts student learning, then employs DPO to tune the teacher model accordingly. Experiments with Llama-3 and TinyLlama models showed significant improvements over baseline methods.
weaknesses: The main drawback of this work is the excessive computational overhead beyond the objective of training the student model. Although the authors discussed this additional computation in detail in Section 6 and Appendix E, I believe that the impact on the paper's practicality cannot be dismissed through discussion alone. The majority of the additional computational cost comes from local data influence for the student, where one step of training is required for each sample, along with evaluation on the reference dataset. To accelerate this process, the authors used 8xH100, which is a very expensive overhead. This makes me question whether we could actually achieve similar gains by investing these resources in using stronger teacher models and building more sophisticated reward model pipelines[1]. I encourage the authors to (1) discuss potential directions that could directly reduce the unit cost of local data influence, rather than encouraging more computational resources, thereby enhancing the promise of local data influence-based approaches. (2) present the additional monetary costs for each method (i.e., APIs used for baseline methods and computational resources used for acceleration) to improve the fairness and transparency of the comparison.

[1] Snell, Charlie, et al. "Scaling llm test-time compute optimally can be more effective than scaling model parameters." _arXiv preprint arXiv:2408.03314_ (2024).

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. Is there an easy way to see how the effectiveness of the framework scales with the data? You are welcome to scale down / scale up, to a point where the experiment is reasonable.
soundness: 3
strengths: **Writing**. 
- Introduction is well-written. The motivation is clear, the problem is well-defined, key contributions are listed and aligned with the structure of the paper.
- Related work is well-written, extensive, and up-to-date. Related works is also well-organized in logic, and set up a good foundation between existing line of works and the proposed method.

**Evaluation**.
- Evaluation has good coverage of different baselines, and the selection of baselines are realistic. Generally, the evaluation is comprehensive and thorough.
- Ablation study is comprehensive and thorough. The ablation studies the effectiveness of teacher optimization, seed data, (multiple) iterations, and very clearly demonstrates the generalizability of the method.

**Originality**. The idea of the paper is novel, and well-motivated. 

**Significance**. The proposed method is a good contribution to the field of synthetic data generation for language model training. The proposed method is generalizable to other domains, though with additional overhead as stated in the limitation section.
summary: This paper introduces MONTESSORI-INSTRUCT, a framework to generate synthetic data for training student language models - tailored for the student model's learing process / ability. The method first uses local data influence to measure the utility of synthetic data points for student learning. Then, it optimizes a teacher model with DPO to generate more effective synthetic training data by aligning with the student model's learning preferences. 

The authors evaluate MONTESSORI-INSTRUCT using `Llama3-8B-Instruct` as the teacher and `Llama3-8B/Tinyllama-1`.1B as students. Evaluation on Alpaca Eval and MT-Bench shows that Montessori-Instruct outperforms existing methods like Self-Instruct. The authors also show that Montessori-Instruct can beat GPT-4o on in-domain and out-of-domain evaluation. Ablation studies highlight the effectiveness of using data influence to capture student preferences, the benefits of optimizing teacher parameters, and the robustness across different configurations.
weaknesses: **Scale of experiment.** The limitation section points out that in the experiment, the scale is chosen as a fixed 10k data points. Ablation on the scale of experiment will be helpful to show the generalizability of the method on the scale of data.

Meta-review: This paper proposes to use influence function to select training examples in the iterative instruction tuning process. Despite increasing the computation cost due to evaluating the influence function, it can outperform other iterative improvement methods and the observations are valuable for future studies.

Decision: Accept (Poster)