← Distillation From First Principles

Distillation Versus Other AI Improvements

Distillation is a learning mechanism, not a synonym for compression or improvement. This chapter separates the four transfer families from fine-tuning, self-training, reinforcement learning, quantisation, pruning, merging, and retrieval.

A word that describes every improvement describes none. A model is called distilled when it is smaller, trained on another model’s outputs or synthetic data, quantised, merged with another checkpoint, or given a memory of tool calls. These operations can all be useful. They are not the same operation; one name hides the questions that determine whether they worked.

The confusion is practical. A team that believes quantisation is distillation may expect a smaller file to improve accuracy. A team that treats every synthetic dataset as a distillation dataset may ignore the teacher’s errors or the terms under which its outputs were produced. A team that treats teacher agreement as proof of capability may deploy a student that has learned to imitate the teacher’s mistakes.

This chapter draws boundaries. Its central claim is:

Distillation is defined by the learning mechanism and the source of supervision, not by whether the resulting model is smaller, faster, more accurate, or trained on synthetic data.

The chapter defines distillation, separates four transfer families, distinguishes neighbouring techniques, supplies a five-axis framework, and works through seven examples. The aim is a procedure for classifying a pipeline and naming its evidence, not a rigid dictionary.

What makes a method distillation?

For this book, a method is model distillation when a student model is trained to acquire behaviour from a teacher, and the teacher’s behaviour is the source of the transfer target. The definition has three parts: a teacher or teacher-like source; a student model being trained; and a training target derived from the teacher’s behaviour rather than only from ground-truth labels.

The teacher need not be larger than the student. It may be an ensemble, a model trained on more data, a frozen checkpoint, a verifier, or a specialised system. The student need not be smaller either; distillation can transfer behaviour into a similar-sized model or preserve behaviour during adaptation. The words describe roles, not guarantees about quality.

The third condition is the one most often missed. A teacher’s behaviour can be supplied as probabilities, logits, hard labels, features, attention maps, sequences, preferences, or trajectories. Hinton et al. (2015) introduced the widely used temperature-scaled soft-target form, but soft targets are not the definition. Buciluǎ et al. (2006) trained a smaller model on labels produced by an ensemble; the supervision was label-based, and the method was still an early form of model compression through teacher-generated targets.

Synthetic data is not sufficient. A dataset generated by a template or unrelated model does not become distillation because it is artificial. Teacher-generated data can be distillation when it carries the teacher’s behaviour into a student’s training.

A smaller model is not sufficient either. Pruning, quantisation, low-rank adaptation, and merging can reduce or change a model, but none is teacher–student learning by itself. A compressed model may never have seen a teacher; a distilled model may be no smaller than its teacher.

Most confusion about the word comes from collapsing five different things into one. Keep them separate:

  • the supervision source: labels, teacher outputs, rewards, or preferences;
  • the mechanism: supervised fitting, representation matching, or policy optimisation;
  • the object optimised: parameters, a dataset, an adapter, or a memory;
  • the outcome: compression, specialisation, accuracy, or calibration;
  • the permission for the teacher, the data, the outputs, and the resulting artefact.

The supervision source and the mechanism decide whether teacher–student learning is happening at all, and the object optimised distinguishes, for example, model distillation from dataset distillation. The outcome and the permission decide whether it worked and whether it may be used.

The four transfer families

The book uses four family names. They are analytical categories, not a claim that every paper uses the same vocabulary.

Model distillation

Model distillation transfers learned behaviour from a teacher to a student. The student sees inputs and a representation of the teacher’s response: probabilities, logits, labels, features, sequences, or actions. Its parameters are updated so that its behaviour becomes more like the teacher’s.

The transfer is behavioural, not a weight copy. The student has its own architecture and capacity; it may reproduce some teacher outputs while computing them differently, or learn an approximation that differs in detail. DistilBERT is a transformer example: a smaller model is trained with output distributions and a masked-language objective (Sanh et al., 2019).

Model distillation is evaluated on held-out task data. Teacher agreement is a diagnostic, not a substitute for correctness. E1 makes the point: mixed distillation had lower mean held-out accuracy than the hard-label baseline but lower cross-entropy and lower measured calibration error. The method was still model distillation; the result was not an endorsement.

Dataset distillation

Dataset distillation changes the object being optimised. The aim is to construct a compact dataset that captures useful training information from a larger dataset. A model trained on it should approximate one trained on the full dataset. Wang et al. (2018) formulate this as synthesising a small dataset; later work matches gradients (Zhao et al., 2021) or training trajectories (Cazenavette et al., 2022). The optimisation procedure changes, but the object remains the dataset.

A dataset-distillation algorithm does not necessarily train a separate teacher. It may optimise synthetic inputs against a model; the output is still a dataset, not a distilled student. That dataset can later train a model, and that later training may itself be model distillation if teacher behaviour is involved.

Dataset distillation is also not ordinary data filtering. Filtering selects or weights existing examples; dataset distillation synthesises examples, often with a bilevel objective in which synthetic data are optimised so that a model trained on them behaves like a model trained on the original data. Chapter 16 treats the methods in detail.

Reasoning distillation

Reasoning distillation transfers intermediate reasoning behaviour rather than only final answers. The student may learn from traces, step labels, rationales, or verifier feedback. Hsieh et al. (2023) add rationales from a larger model as supervision for a smaller model; Magister et al. (2023) fine-tune on chain-of-thought outputs; Lightman et al. (2023) study process supervision. They are related but not identical; evidence is task-specific.

The central distinction is between a correct answer and a faithful, correct process. A student can produce the right answer through a shortcut; a trace can be plausible without being the process that produced it. Reproducing a trace does not prove the student uses the same computation or will generalise. Chain-of-thought prompting can improve performance (Wei et al., 2022), but that is not evidence that an explanation is faithful.

Reasoning distillation is an emerging area with a verification problem. A correct answer is necessary but not sufficient evidence of transferred reasoning. Chapter 18 develops the distinction; Chapters 19–22 examine variants.

Agent skill transfer

Agent skill transfer covers policies, action sequences, tool decisions, and reusable procedures. A student may learn from demonstrations, trajectories, or a teacher policy’s actions; the object can be a policy, procedure, or memory.

Three mechanisms are often conflated. Behavioural cloning trains a policy on state–action pairs; teacher demonstrations can make it policy distillation, while human demonstrations are imitation learning. Policy distillation matches a teacher’s actions, values, or trajectories. Procedural memory stores a workflow outside the weights and can improve an agent without weight-level distillation.

ReAct illustrates an agent that interleaves reasoning and actions; Toolformer shows a model learning when to call APIs (Yao et al., 2023; Schick et al., 2023). Neither is a distillation study; they illustrate agent behaviour, not evidence that training on demonstrations transfers a general skill. A single successful run is weak evidence; evaluation needs held-out tasks and safety checks. Chapters 26–28 treat these questions.

The classification rule

The four families are not mutually exclusive. Teacher-trace training is both reasoning and model distillation; dataset-distillation output can feed model distillation; an agent policy can be distilled into weights and also use external memory.

Ask four questions:

  1. What is the supervision source? Ground truth, teacher output, reward, preference, or the model’s own predictions.
  2. What is the transfer mechanism? Supervised fitting, representation matching, policy optimisation, data synthesis, or retrieval.
  3. What is optimised? Model parameters, a dataset, an adapter, a policy, or a memory store.
  4. What is the intended outcome? Accuracy, calibration, compression, specialisation, latency, safety, or legal compliance.

A method may receive more than one label. Say which mechanism is doing the work and which evidence would show it worked.

Neighbouring techniques

Supervised learning and supervised fine-tuning. Supervised learning trains on labelled examples; supervised fine-tuning (SFT) applies the same idea to a pretrained model. Distillation can use the same optimiser, loss, and loop; what distinguishes it is the target’s source. Ground-truth labels make it ordinary supervised learning. Teacher-generated targets can make it sequence-level or response-based distillation, even when described as SFT. “SFT” names the training interface, not the supervision source. Ouyang et al. (2022) combine SFT with reinforcement learning from human feedback; that is alignment training, not distillation in this book’s sense.

Self-training. Self-training uses pseudo-labels from a model’s own predictions or a teacher to train on unlabelled data. Xie et al. (2020) use a teacher to pseudo-label unlabelled data and train a student with noise and augmentation; this is self-training, not necessarily logit distillation. Self-training and self-distillation overlap but are not synonyms. Self-distillation derives a teacher from the same family or weights, as in born-again networks (Furlanello et al., 2018); self-training can use a separate teacher, a checkpoint, or its own predictions. Both can amplify errors. Chapter 21 treats the distinction.

Reinforcement learning. Reinforcement learning optimises a policy through interaction and reward. Distillation can use it in two ways: a teacher generates trajectories for imitation, or teacher feedback becomes a reward. DeepSeek-R1 develops reasoning with reinforcement learning and then distils outputs into smaller models (DeepSeek-AI et al., 2025). That does not make reinforcement learning itself a distillation method.

Preference optimisation. Preference optimisation learns from comparisons or rankings. Direct Preference Optimization (DPO) derives an objective that avoids an explicit reward model and a separate reinforcement-learning loop (Rafailov et al., 2023). It is not automatically distillation. It becomes a transfer mechanism when preferences come from a teacher or expert process and a student learns the preferred behaviour. The boundary depends on provenance, not the acronym.

Quantisation and pruning. Quantisation changes numerical representation, usually to reduce memory or computation; Jacob et al. (2018) describe an integer-only scheme and quantisation-aware training. Pruning removes parameters, connections, or structures; Deep Compression combines pruning, trained quantisation, and Huffman coding to reduce storage (Han et al., 2016). Neither supplies a teacher signal. Distillation can help recover behaviour after pruning, but that is a combination.

Low-rank adaptation. LoRA freezes a base model and learns low-rank updates (Hu et al., 2022); QLoRA backpropagates through a frozen quantised base into adapters (Dettmers et al., 2023). They determine which parameters are trained, not where the teaching signal comes from. An adapter can be trained by distillation, but LoRA without a teacher is parameter-efficient fine-tuning.

Model merging. Merging combines parameters, adapters, or updates by arithmetic in parameter space. A merged model may inherit useful behaviour, but no student is trained to match a teacher unless such a stage is added. An ensemble teacher supplies outputs that a student learns from; a merge combines weights without a student learning from outputs.

Retrieval augmentation. Retrieval supplies external information to a model’s context at inference time. The base weights need not change. That is an access mechanism, not weight-level distillation. A distillation process can use retrieval to construct examples, and a retrieval system can itself be distilled, but retrieval alone does not transfer behaviour into parameters. Chapter 24 treats retrieval distillation.

Compression is an objective, not a method

The book uses model compression for the broader engineering objective of reducing storage or computation through distillation, pruning, quantisation, low-rank methods, or combinations. Compression is what the engineer wants. Distillation is one possible mechanism.

Compression is often reported with a single number, but at least six different quantities hide behind it:

  • parameter count, which does not capture dtype or architecture;
  • serialised size, which depends on precision and format;
  • runtime memory, which includes activations and caches;
  • compute, which depends on kernels and hardware;
  • latency, which is measured on a defined system, batch size, and sequence length;
  • output quality, which is task performance, calibration, robustness, and safety on held-out data.

A parameter count is not a serialised model size. A serialised size is not runtime memory. Runtime memory is not compute. Compute is not latency. None of these is output quality.

A smaller parameter count is not a guarantee of lower end-to-end latency. E1’s latency measurements were host-sensitive, so Chapter 01 treats parameter count and artefact size as stable cost measures and latency as a diagnostic to be remeasured on the target system. Chapter 33 develops compression and runtime evaluation.

A five-axis comparison framework

The framework asks five questions: what is transferred; what the learner sees; what is optimised; what demonstrates success; and what permissions are required. Each answer is a prompt, not a verdict.

To use the table, find the row closest to a pipeline and then answer the five questions for the actual system. Where the answers differ from the row, the label probably needs to change as well. The last two columns say what evidence a claim of success needs and which permissions must be on record before the work starts.

Method Transferred Learner sees Optimised Success evidence Permission focus
Model distillation Teacher behaviour Inputs plus outputs, features, or sequences Student parameters Held-out task, calibration, agreement, cost Teacher licence, output terms, distribution
Dataset distillation Compressed training information Synthetic inputs and targets Synthetic dataset Condensed-data model versus full-data baseline Source dataset, personal data, provenance
Reasoning distillation Intermediate reasoning Problems plus traces, steps, or verifier feedback Student, sometimes a verifier Final accuracy plus process validity Trace and output terms, contamination
Agent skill transfer Policy, trajectory, procedure States, actions, tools, outcomes Policy, weights, or memory Held-out task success, tool validity, safety Demonstrations, user data, tool terms
Supervised fine-tuning Labelled behaviour Inputs and labels Model or adapter Held-out task performance Dataset licence, personal data
Self-training Pseudo-labelled behaviour Unlabelled inputs plus own predictions Model Performance versus baseline; error amplification Data provenance, output terms
Reinforcement learning Policy States, actions, rewards, environment feedback Policy parameters Return, task success, safety Environment, tool, reward rights
Preference optimisation Preference ranking Response pairs or rankings Policy or preference objective Held-out preference quality Annotator consent, data rights, model terms
Quantisation / pruning Precision or sparsity Weights and calibration data Ranges, mask, or structure Accuracy, size, memory, latency Model licence, derivative terms
LoRA / PEFT Low-rank update Base model plus task data Adapter Task performance, memory cost Base-model licence, adapter distribution
Model merging Combined update Component weights or adapters Merged parameters Task performance All component licences
Retrieval augmentation External context Query plus documents Index or retriever Answer quality, citation, freshness Corpus rights, personal data

The table is a prompt, not a verdict; implementations differ, and a later row is not thereby better.

Worked classification examples

A — Classical classifier distillation. A larger classifier supplies output distributions to a smaller classifier trained on the same inputs and labels. The teaching signal is teacher behaviour; the objective combines hard-label cross-entropy with distribution matching; success is held-out accuracy, with calibration and agreement separate. Permissions cover the teacher, outputs, data, and student distribution. E1 is an instance: 17,412 teacher parameters and 228 student parameters; 66.87% mean accuracy for the hard-label baseline and 64.20% for mixed distillation, with lower cross-entropy and calibration error for the mixed student. The classification does not depend on which arm won.

B — Quantised language model. A model is converted to lower precision. No teacher is introduced; the target is the numerical representation. This is quantisation, a compression technique. If the model is later trained with a teacher signal, the pipeline has a distillation stage; the quantisation stage remains quantisation. Calling the whole pipeline “distillation” hides which stage caused which change.

C — Synthetic instruction training. A teacher generates instruction–response pairs and a smaller model is fine-tuned on them. The teaching signal is the teacher’s generated behaviour; this is reasonably classified as sequence-level or response-based distillation, and also as SFT in the implementational sense. The two labels describe different aspects. Synthetic data does not settle permissions: teacher output terms, seed-data rights, personal data, and student distribution all need records.

D — Dataset condensation. A large labelled dataset is replaced by a smaller optimised dataset. The optimisation target is the synthetic data; a model trained on it is the evaluation instrument. This is dataset distillation, not model distillation and not model compression of the deployed model. The source dataset’s licence and personal-data obligations do not disappear because the output is synthetic.

E — Reasoning supervision. A student learns from verified reasoning steps produced by an authorised teacher. The source is intermediate reasoning behaviour; the object is the student’s parameters; the mechanism is supervised training on traces or step targets. The method is both reasoning distillation and model distillation. Success needs held-out problems, process validity where checkable, and generalisation. A correct final answer alone does not prove faithful reasoning.

F — Agent trajectory learning. A student agent observes successful tool choices and action sequences. If the demonstrations come from a teacher policy, this is policy distillation or behavioural cloning from a teacher; if from humans, it is imitation learning. If the procedure is stored in external memory, the base weights may not change; that is procedural memory, not weight-level distillation. Evaluation needs held-out tasks and environments, task success, tool validity, and safety.

G — Hybrid compression pipeline. A team distils a teacher into a student, prunes the student, and quantises the result. The five axes separate the stages:

  • Transferred: stage one transfers teacher behaviour into student weights; pruning and quantisation change structure and precision without a new teacher signal.
  • Learner sees: stage one sees inputs, labels, and teacher outputs; later stages see weights and calibration data.
  • Optimised: stage one optimises student parameters; stage two optimises a sparsity mask; stage three optimises numerical ranges.
  • Success: each stage needs its own comparison — student versus baseline, pruned versus unpruned, quantised versus unquantised — with accuracy, calibration, size, memory, and latency reported separately.
  • Permission: stage one needs the teacher licence and output terms; the student licence governs distribution; pruning and quantisation may create a derivative with notice and redistribution conditions; training and calibration data need records.

The pipeline is partly distillation, partly compression; naming both is more accurate.

Overlap, evaluation, and permission

Overlap is normal. A reasoning-trace pipeline can be model and reasoning distillation; dataset distillation can feed model distillation; an agent pipeline can combine policy distillation with memory. The book does not force exclusive boxes. It asks the reader to name the mechanism at each stage and assign evidence and permissions accordingly.

Labels also remain contested: “reasoning distillation” covers traces, verifier selection, and preference alignment; “agent skill transfer” covers behavioural cloning, policy distillation, and memory; “self-distillation” covers born-again networks and pseudo-labelling.

A method label does not establish improvement. E1’s distilled student was worse on mean accuracy than its baseline, and a quantised, pruned, or merged model can also regress. The comparison needs a baseline with comparable data and budget, a held-out set not used for tuning, and metrics that match the claim. A sophisticated method is not automatically better than supervised fine-tuning; sometimes the simpler baseline wins.

Every method creates a different rights question. This section records the questions, not legal advice; Chapters 36–39 develop the framework.

Fine-tuning licensed weights. A model licence may permit modification and distribution subject to conditions. The Llama 3.2 Community Licence permits conditional derivative use with naming, notice, acceptable-use, and monthly-active-user conditions; it is not an OSI open-source licence (L-005; retrieved 12 November 2026).

Using a commercial API to generate training data. Provider terms are not uniform. The OpenAI Services Agreement prohibits using Output to develop competing AI models, subject to a narrow Permitted Exception (L-016; updated 1 December 2025). The Anthropic Commercial Terms prohibit building a competing product or service, including training competing models, without express approval (L-017; effective 17 June 2025). The Gemini API Additional Terms prohibit developing competing models and impose compliance duties (L-019; effective 23 March 2026). These are findings about specific documents, not general rules.

Training on an external dataset. Dataset licence, copyright, database rights, and personal-data obligations are separate questions. The GDPR imposes lawful-basis, purpose-limitation, minimisation, and erasure requirements for personal data (L-021); the Database Directive creates a sui generis right for substantial investment in database contents (L-026). A viewable dataset is not thereby licensed for training or redistribution.

Quantising and redistributing weights. A quantised checkpoint is a derivative artefact; the licence may impose notice, attribution, use restrictions, or redistribution conditions. The Gemma Terms of Use treat distillation using intermediate representations or synthetic outputs as a Model Derivative, with distribution conditions and use restrictions (L-004; last modified 1 April 2026). A smaller file is not a cleaner licence.

Distilling from an open-weight teacher. Open weights are not unrestricted permission to train, fine-tune, or redistribute a derivative. The teacher licence and output terms must be checked for the action; a model card’s licence tag is a starting point, not a complete legal analysis.

Reusing agent trajectories. Trajectories can contain personal data, confidential information, credentials, or third-party content. Their use may engage privacy, confidentiality, contract, and tool-provider terms; a model-generated trajectory does not remove those obligations.

Permission is action-specific. The same model may be permitted for evaluation, restricted for fine-tuning, and prohibited for competing-model training; the same dataset may be usable for research and unusable for commercial distribution. The book records the document, version, retrieval date, and intended action rather than inferring permission from technical access.

What the reader can now distinguish

Distillation is a relationship between a source of behaviour and a learner. Model distillation trains a student on a teacher’s behaviour. Dataset distillation optimises a compact dataset. Reasoning distillation transfers intermediate reasoning behaviour, subject to verification. Agent skill transfer covers policies, trajectories, tool use, and procedures, and may or may not change model weights.

Supervised fine-tuning, self-training, reinforcement learning, preference optimisation, quantisation, pruning, low-rank adaptation, merging, and retrieval are neighbouring techniques. Some combine with distillation; none becomes distillation merely by appearing in the same pipeline. The five-axis framework asks what is transferred, what the learner sees, what is optimised, what demonstrates success, and what permission is required. Those questions survive changes in terminology.

Limits of this chapter’s evidence

The four families and the five-axis framework are this book’s analytical categories, not a vocabulary that every paper shares. The only book result in the chapter is E1, one synthetic task with three seeds, used here to show that a method’s classification does not depend on whether it won. The cited papers illustrate methods; they are not evidence that any family works in general, and evidence for reasoning distillation and agent skill transfer remains task-specific. The legal notes are findings about specific documents on the dates recorded, not legal advice; Chapters 36–39 develop the framework.

What comes next

The next chapter narrows the focus to the teacher and the student: what the student can access, what the teacher can supply, and which capacity and compatibility constraints make a pair viable. The taxonomy supplies vocabulary; Chapter 03 supplies specifications.

References

Buciluǎ, C., Caruana, R. and Niculescu-Mizil, A. (2006). Model Compression. Proceedings of the 12th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 535–541. https://doi.org/10.1145/1150402.1150464

Cazenavette, G., Wang, T., Torralba, A., Efros, A. A. and Zhu, J.-Y. (2022). Dataset Distillation by Matching Training Trajectories. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. arXiv:2203.11932. https://arxiv.org/abs/2203.11932

DeepSeek-AI, Guo, D., Yang, D., Zhang, H., Song, J., Zhang, R., et al. (2025). DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning. Nature, 645, 633–638. https://doi.org/10.1038/s41586-025-09422-z

Dettmers, T., Pagnoni, A., Holtzman, A. and Zettlemoyer, L. (2023). QLoRA: Efficient Finetuning of Quantized LLMs. Advances in Neural Information Processing Systems. arXiv:2305.14314. https://arxiv.org/abs/2305.14314

Furlanello, T., Lipton, Z. C., Tschannen, M., Itti, L. and Anandkumar, A. (2018). Born-Again Neural Networks. Proceedings of the 35th International Conference on Machine Learning. arXiv:1805.04770. https://arxiv.org/abs/1805.04770

Han, S., Mao, H. and Dally, W. J. (2016). Deep Compression: Compressing Deep Neural Networks with Pruning, Trained Quantization and Huffman Coding. International Conference on Learning Representations. arXiv:1510.00149. https://arxiv.org/abs/1510.00149

Hinton, G., Vinyals, O. and Dean, J. (2015). Distilling the Knowledge in a Neural Network. NIPS 2014 Deep Learning Workshop. arXiv:1503.02531. https://arxiv.org/abs/1503.02531

Hsieh, C.-Y., Li, C.-L., Yeh, C.-K., Nakhost, H., Fujii, Y., Ratner, A., Krishna, R., Lee, C.-Y. and Pfister, T. (2023). Distilling Step-by-Step! Outperforming Larger Language Models with Less Training Data and Smaller Model Sizes. Findings of the Association for Computational Linguistics: ACL 2023. arXiv:2305.02301. https://arxiv.org/abs/2305.02301

Hu, E. J., Shen, Y., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L. and Chen, W. (2022). LoRA: Low-Rank Adaptation of Large Language Models. International Conference on Learning Representations. arXiv:2106.09685. https://arxiv.org/abs/2106.09685

Jacob, B., Kligys, S., Chen, B., Zhu, M., Tang, M., Howard, A., Adam, H. and Kalenichenko, D. (2018). Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. arXiv:1712.05877. https://arxiv.org/abs/1712.05877

Lightman, H., Kosaraju, V., Burda, Y., Edwards, H., Baker, B., Lee, T., Leike, J., Schulman, J., Sutskever, I. and Cobbe, K. (2023). Let’s Verify Step by Step. International Conference on Learning Representations. arXiv:2305.20050. https://arxiv.org/abs/2305.20050

Magister, L. C., Mallinson, J., Adamek, J., Malmi, E. and Severyn, A. (2023). Teaching Small Language Models to Reason. Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics. arXiv:2212.08410. https://arxiv.org/abs/2212.08410

Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., et al. (2022). Training Language Models to Follow Instructions with Human Feedback. Advances in Neural Information Processing Systems. arXiv:2203.02155. https://arxiv.org/abs/2203.02155

Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C. D. and Finn, C. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Advances in Neural Information Processing Systems. arXiv:2305.18290. https://arxiv.org/abs/2305.18290

Sanh, V., Debut, L., Chaumond, J. and Wolf, T. (2019). DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter. NeurIPS 2019 Energy Efficient Machine Learning and Cognitive Computing Workshop. arXiv:1910.01108. https://arxiv.org/abs/1910.01108

Schick, T., Dwivedi-Yu, J., Dessì, R., Raileanu, R., Lomeli, M., Zettlemoyer, L., Cancedda, N. and Scialom, T. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. Advances in Neural Information Processing Systems. arXiv:2302.04761. https://arxiv.org/abs/2302.04761

Wang, T., Zhu, J.-Y., Torralba, A. and Efros, A. A. (2018). Dataset Distillation. arXiv:1811.10959. https://arxiv.org/abs/1811.10959

Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., Chi, E., Le, Q. V. and Zhou, D. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. Advances in Neural Information Processing Systems. arXiv:2201.11903. https://arxiv.org/abs/2201.11903

Xie, Q., Luong, M.-T., Hovy, E. and Le, Q. V. (2020). Self-training with Noisy Student improves ImageNet classification. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. arXiv:1911.04252. https://arxiv.org/abs/1911.04252

Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K. and Cao, Y. (2023). ReAct: Synergizing Reasoning and Acting in Language Models. International Conference on Learning Representations. arXiv:2210.03629. https://arxiv.org/abs/2210.03629

Zhao, B., Mopuri, K. R. and Bilen, H. (2021). Dataset Condensation with Gradient Matching. International Conference on Learning Representations. arXiv:2006.05929. https://arxiv.org/abs/2006.05929

Anthropic Commercial Terms of Service. Effective 17 June 2025. https://www.anthropic.com/legal/commercial-terms (retrieved 12 November 2026).

Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases. https://eur-lex.europa.eu/eli/dir/96/9/oj (retrieved 12 November 2026).

Gemini API Additional Terms of Service. Effective 23 March 2026. https://ai.google.dev/gemini-api/terms (retrieved 12 November 2026).

Gemma Terms of Use. Last modified 1 April 2026. https://ai.google.dev/gemma/terms (retrieved 12 November 2026).

Llama 3.2 Community License Agreement. Released 25 September 2024. https://www.llama.com/llama3_2/license/ (retrieved 12 November 2026).

OpenAI Services Agreement. Updated 1 December 2025; effective 1 January 2026. https://openai.com/policies/services-agreement/ (retrieved 12 November 2026).

Regulation (EU) 2016/679 (General Data Protection Regulation). https://eur-lex.europa.eu/eli/reg/2016/679/oj (retrieved 12 November 2026).