Structural Instruction Tuning

• Structural instruction tuning is a family of methods that imposes internal constraints on data, responses, and representations to improve model alignment.
• It leverages techniques like pairwise mutual consistency, curriculum ordering, and explicit schemas to address limitations of text-only instruction tuning.
• Practical outcomes include enhanced coherence, robustness, and effective handling of diverse modalities while mitigating superficial shortcuts.

Searching arXiv for recent and relevant papers on structural instruction tuning and closely related approaches. Structural instruction tuning is best understood as a family of approaches that treat instruction tuning as a problem of preserving or imposing internal structure on data, supervision, representations, or outputs, rather than merely accumulating large numbers of plausible prompt–response pairs. Across recent work, “structure” appears in several non-equivalent but related senses: the mutual compatibility of an instruction and its response, the temporal order of examples in a curriculum, latent task-selective factors in a causal model, explicit schemas such as JSON, and modality-specific encodings for graphs, assembly, proteins, abstract syntax trees, or process graphs (Yang et al., 17 Apr 2025, Lee et al., 2023, Chen et al., 2024, Gao et al., 2023, Tang et al., 2023, Wang et al., 14 Mar 2025). This suggests that structural instruction tuning is not a single algorithmic recipe, but an umbrella perspective on how instruction-tuning signals should be organized.

1. Structural loci in instruction tuning

A useful way to organize the literature is by the locus at which structure is imposed.

Structural locus	Representative papers	Core idea
Pair formation	MAIN (Yang et al., 17 Apr 2025), Cycle-Instruct (Shen et al., 22 Aug 2025)	Pair quality is joint and bidirectional
Example ordering	Curriculum Instruction Tuning (Lee et al., 2023)	Data order carries pedagogical structure
Task selection and dataset geometry	INSTA (Lee et al., 2024), InfinityInstruct-Subject (Du et al., 9 Jul 2025), DoIT dynamics (Song et al., 2023)	Instruction space has coverage, depth, and ability structure
Latent factor selection	SIT (Chen et al., 2024)	Instructions select task-required causal factors
Explicit schema	JsonTuning (Gao et al., 2023)	Instruction tuning becomes structure-to-structure generation
Modality-specific structure	GraphGPT (Tang et al., 2023), ASMA-Tune (Wang et al., 14 Mar 2025), SEPIT (Wu et al., 2024), TIT (Jiang et al., 10 Oct 2025), InstruBPM (Çelikmasat et al., 12 Dec 2025)	Structured inputs are encoded before or during instruction tuning

The literature does not present a single formal theory of structure. Instead, different papers identify different failure modes of standard text-only SFT. Some argue that instruction tuning neglects the relation between prompt and answer; others argue that it ignores ordering effects, causal invariances, output schemas, or domain-native structure. A plausible implication is that “structure” in this area should be read as a constraint on admissible mappings, not merely as additional metadata.

A second common theme is that standard instruction tuning often treats a dataset as an unordered bag of instruction–response pairs, or treats each side of a pair independently. Structural approaches reject at least one of those assumptions. In that sense, they are united less by a common architecture than by a common critique of decomposed, text-only, or one-sided supervision.

2. Pairwise structure: mutual alignment and cycle consistency

One major line of work places structure at the level of the instruction–response pair itself. MAIN argues that the quality of instruction-tuning data is not the sum of instruction quality and response quality, but the extent to which the two are aligned (Yang et al., 17 Apr 2025). Its formulation introduces a forward model $M_f := p(R\mid I)$ and a reverse model $M_r := p(I\mid R)$, initialized from a shared base model, and trains them in an alternating loop. The forward loss is

$$\mathcal{L}_f = \alpha \cdot \mathcal{L}(\hat{I}, R) + (1-\alpha) \cdot \mathcal{L}(I, R),$$

while the reverse loss is

$$\mathcal{L}_r = \alpha \cdot \mathcal{L}(\hat{R}, I) + (1-\alpha) \cdot \mathcal{L}(R, I).$$

MAIN’s “mutual filter” then retains synthetic pairs whose reverse-generated instruction can regenerate the originating response with low cross-entropy. Operationally, pair quality becomes a near-cycle property under reverse generation and forward reconstruction.

This pair-level structural view is narrower than full task-schema modeling, but it is unusually explicit. MAIN treats instruction tuning as a problem of recoverability and mutual constraint: the instruction should constrain the response, and the response should reveal what instruction it plausibly answered. Empirically, that view is supported by the paper’s filtering ablation: on LLaMA-2-7B, mutual filter yields 58.20 on AlpacaEval versus 56.40 without filtering and 55.26 with score-based filtering, and it also leads on all IFEval metrics (Yang et al., 17 Apr 2025).

Cycle-Instruct pushes this idea further by removing the seed set entirely and using cycle consistency as the supervision signal (Shen et al., 22 Aug 2025). It instantiates a question generator $F_{A\to Q}$ and an answer generator $G_{Q\to A}$, both initialized from the same base model, and defines

$$\mathcal{L}_{\mathrm{cycle}} = \mathbb{E}_{q\sim\mathcal{Q}} \!\Bigl[\ell\bigl(q,\, F_{A\to Q}(G_{Q\to A}(q))\bigr)\Bigr] + \mathbb{E}_{a\sim\mathcal{A}} \!\Bigl[\ell\bigl(a,\, G_{Q\to A}(F_{A\to Q}(a))\bigr)\Bigr].$$

Its preprocessing partitions raw text into question-like and answer-like segments using a simple question-mark heuristic, rewrites them into standardized forms, and then alternates dual self-training. A post hoc filter reconstructs each side and removes the top 5% farthest points within $k$-means clusters using embedding distance. This suggests a broader structural principle: unlabeled text can supervise instruction tuning if valid question–answer pairs are treated as two views of the same latent communicative content.

These pairwise methods also clarify an important limitation. Mutual consistency enforces coherence, not truth. MAIN explicitly notes that a response can be reconstructable from an instruction and still be wrong, biased, unsafe, or hallucinated (Yang et al., 17 Apr 2025). Structural compatibility at the pair level is therefore a partial criterion, not a complete alignment guarantee.

3. Dataset structure: curriculum, task selection, coverage, depth, and ability pacing

A second major family of approaches imposes structure on the dataset as a whole. Curriculum Instruction Tuning argues that instruction tuning should not treat the training set as an unordered bag of prompts and proposes a curriculum over both subject matter and instruction complexity (Lee et al., 2023). Its CORGI dataset is built from 5.6K fine-grained concepts extracted from 1.8K courses across 45 subjects, then expanded into 107K synthetic instruction–response pairs before filtering, with the main released training set containing 66K examples. The central curriculum strategy is interleaving: a global easy-to-hard progression over Bloom’s taxonomy while mixing subjects. Under otherwise identical training configuration, the paper reports gains over random shuffling of +4.76 on TruthfulQA, +2.98 on MMLU, +2.8 on OpenbookQA, and +1.28 on ARC-hard.

This work matters because the structural intervention is purely temporal. It does not modify the model or optimizer; it only changes the sequence in which data are presented. The paper’s explanation is that interleaving preserves global curriculum structure under large-batch training better than local curricula such as blocking, clustering, or spiral ordering. A plausible implication is that structural instruction tuning can operate over training dynamics, not only over example content.

INSTA addresses a different dataset-level problem: which source tasks should be selected for tuning a model toward a specific unseen target task (Lee et al., 2024). It scores instruction similarity by

$$\text{Score}(I_i^T, I_j^{\bar T}) = \cos(E(I_i^T), E(I_j^{\bar T})),$$

using a Sentence Transformer encoder, and ranks candidate source tasks by instruction similarity alone. An aligned version further tunes the instruction encoder to the style of a meta-dataset such as P3 or NIV2. The method is structurally significant because it treats instructions themselves as a representation of task identity. On P3, T5(3B)+INSTA Aligned-P3 reaches 57.97 average, slightly above pairwise transfer selection at 57.86 and above T0-3B at 50.87 (Lee et al., 2024).

InfinityInstruct-Subject generalizes dataset structure from task ordering and selection to the geometry of the instruction space itself (Du et al., 9 Jul 2025). It introduces a hierarchical labeling system with 21,378 fine-grained tags, seed selection rules for long-tail, multi-skill, hard-to-follow, and undertrained instructions, evolutionary synthesis, and deficiency-driven targeted generation. The resulting dataset contains 1,469,391 new instruction samples. Its main conceptual distinction is between coverage and depth. Coverage refers to task-type and knowledge-area span; depth refers to instruction complexity. In a fixed-size subset study, the paper defines depth as

$$\text{Depth} = \log(\text{label count}) \times \text{token-level log loss of the base model},$$

and reports that performance rises with both coverage and depth even at constant sample count.

The DoIT study on Chinese instruction tuning adds an ability-centric view of structure (Song et al., 2023). Its 40k+ human-curated Chinese dataset is organized into ten abilities, and the paper shows that these abilities have different growth rates under changes in data quantity, model size, and construction method. It formalizes two explanatory features: Complexity, associated with model-size sensitivity, and Transference, associated with how much one ability helps others. The practical conclusion is strongly structural: data budgets should be allocated unevenly. In the paper’s later strategies, Ethics and Role-play Chat are reduced to 64 examples each, while Logical Reasoning and Chain of Thought are expanded heavily.

4. Structural supervision through causal factors, schemas, and explicit formats

Another line of work treats instruction tuning as a problem of selecting the right latent factors or making task structure explicit in the input–output representation. SIT formulates instruction tuning through a meta-Structural Causal Model in which latent factors $M_r := p(I\mid R)$0 generate source contexts $M_r := p(I\mid R)$1, while only a task-specific subset of those factors causes the target $M_r := p(I\mid R)$2 (Chen et al., 2024). The practical model learns a task-guided latent mask $M_r := p(I\mid R)$3, selects task-required factors by $M_r := p(I\mid R)$4, reconstructs the source from all factors, predicts the target from selected factors, and regularizes identifiability with a UIC loss and a task-distinction loss. Its full objective is

$M_r := p(I\mid R)$5

This is perhaps the most explicit attempt in the literature to define structural instruction tuning causally rather than procedurally.

JsonTuning places structure not in latent selection but in the external representation of tasks (Gao et al., 2023). It defines input and output JSON structures

$M_r := p(I\mid R)$6

and treats the model as a mapping $M_r := p(I\mid R)$7. Label space $M_r := p(I\mid R)$8 and control information $M_r := p(I\mid R)$9, implemented with JSON Schema primitives such as type, description, items, and properties, become part of the supervision signal. This approach improves the average score from 23.90 for TextTuning to 27.69 for JsonTuning across MMLU, BBH, NER, RE, EE, and NL2SQL, with especially large gains on structured tasks and robustness under prompt and label perturbations (Gao et al., 2023).

“Unified Text Structuralization with Instruction-tuned LLMs” demonstrates an even lighter-weight schema idea: Prefix + Text + Suffix (Ni et al., 2023). The prefix specifies the extraction task, and the suffix specifies the desired output as structured data. The method uses already instruction-tuned LLMs rather than training a new one, but it is still structurally relevant because it separates task semantics from output-form semantics at prompt time. On ACE2005, GPT-3 with this prompting scheme reaches 74.31 on NER, 46.95 on EE, and 40.28 on RE in zero-shot settings, well below supervised task-specific systems but strikingly strong given the absence of task-specific training (Ni et al., 2023).

Taken together, these papers show two distinct structural strategies. One makes latent task structure explicit and task-selective; the other externalizes structure into schemas, fields, and serialization. Both oppose the idea that free-form text alone is always the best substrate for instruction tuning.

5. Modality-specific structural instruction tuning

A large portion of the recent literature applies structural instruction tuning to domains where plain-text token streams are known to be inadequate. In these cases, the structural intervention is often architectural as well as data-centric.

GraphGPT is an early graph-specific example (Tang et al., 2023). It combines a pretrained graph encoder, text-graph grounding, a lightweight graph-text alignment projector, and a Vicuna backbone. Instead of verbalizing graph structure as long text, it inserts learned graph tokens

$$\mathcal{L}_f = \alpha \cdot \mathcal{L}(\hat{I}, R) + (1-\alpha) \cdot \mathcal{L}(I, R),$$0

into the prompt stream and trains in two stages: self-supervised graph matching, then task-specific graph instruction tuning. The paper’s central claim is that graphs should not be flattened naively into natural language because topology is weakly preserved and prompt length explodes.

ASMA-Tune makes the analogous move for assembly code (Wang et al., 14 Mar 2025). It uses an assembly encoder $$\mathcal{L}_f = \alpha \cdot \mathcal{L}(\hat{I}, R) + (1-\alpha) \cdot \mathcal{L}(I, R),$$1, a projector $$\mathcal{L}_f = \alpha \cdot \mathcal{L}(\hat{I}, R) + (1-\alpha) \cdot \mathcal{L}(I, R),$$2, and a pretrained decoder LLM $$\mathcal{L}_f = \alpha \cdot \mathcal{L}(\hat{I}, R) + (1-\alpha) \cdot \mathcal{L}(I, R),$$3, with fusion

$$\mathcal{L}_f = \alpha \cdot \mathcal{L}(\hat{I}, R) + (1-\alpha) \cdot \mathcal{L}(I, R),$$4

The model is trained in two stages: projector-only alignment on 292k simplified-description examples, followed by joint projector+LLM instruction tuning on 115k detailed, conversational, and reasoning examples. On BCSD, ASMA-Tune-13B reaches average MRR 0.218 versus 0.185 for GPT-4-Turbo, and the full training pipeline reaches average Recall@1 50.86, with removal of the assembly encoder dropping that to 24.41 (Wang et al., 14 Mar 2025).

SEPIT performs a related fusion for proteins (Wu et al., 2024). It augments ESM2-650M with a structure-aware module based on residue 3D geometry, adds the structural relation matrix $$\mathcal{L}_f = \alpha \cdot \mathcal{L}(\hat{I}, R) + (1-\alpha) \cdot \mathcal{L}(I, R),$$5 to attention logits, warms the encoder with denoising and protein-text contrastive learning, and then instruction-tunes an LLM through a linear projector. A final MoE stage refines the LLM while keeping the protein encoder frozen. The framework is trained on 5,475,084 training instructions plus supplementary data, and the structure-enhanced variants consistently outperform sequence-only PIT baselines on both open-ended generation and closed-set answering (Wu et al., 2024).

TIT applies the structural idea to code translation via normalized linearized ASTs (Jiang et al., 10 Oct 2025). It parses source code with Tree-sitter, rewrites the tree into a language-agnostic structural representation by retaining universal nodes, normalizing semi-universal nodes, and pruning language-specific nodes, then aligns source tree nodes to target snippets with a contrastive matching model. A dual-stage tree instruction-tuning pipeline first learns structure-to-snippet mappings and then full translation. The paper reports success-rate improvements of 1.22×–1.75× over base LLM-based translators and substantial reductions in syntactic confusion (Jiang et al., 10 Oct 2025).

InstruBPM shows that the same logic can operate on graph-serialized software-engineering outputs (Çelikmasat et al., 12 Dec 2025). It instruction-tunes Qwen3-4B-Instruct-2507 with LoRA to map natural-language process descriptions to BPMN process graphs represented in DOT. The tuned model reaches 99.44 Relative Graph Edit Distance, outperforming untuned open baselines and proprietary models under the paper’s prompting regime, and largely removes the need for assisted zero-shot prompt scaffolding (Çelikmasat et al., 12 Dec 2025). This is notable because the paper achieves structural fidelity primarily through ordinary supervised instruction tuning over clean text–graph pairs rather than through a graph-specific loss.

These domain-specific systems differ in representation—graph tokens, projected assembly embeddings, geometric protein biases, linearized ASTs, DOT graphs—but they share a methodological thesis: when the source modality has graph structure, tree structure, sparse semantics, or strict output constraints, structural instruction tuning is more effective when the supervision and architecture respect that structure directly.

6. Diagnostics, misconceptions, and open problems

A recurring misconception is that stronger instruction-tuning benchmarks necessarily imply deeper instruction following. “Do Models Really Learn to Follow Instructions?” directly challenges that view (Kung et al., 2023). On NatInst-V2, models trained with simplified task definitions that preserve output-space information but remove semantics often perform nearly as well as those trained with original definitions; delusive examples with wrong input–output mappings can remain competitive in low-resource settings; and a random baseline constrained to the correct output space reaches 42.65% exact match, close to instruction tuning at about 43% in the low-resource classification setting. The paper’s interpretation is that current instruction tuning often exploits shallow regularities such as output labels, output format, and task priors.

A second diagnostic line studies internal behavior shifts rather than external scores. “From Language Modeling to Instruction Following” reports that instruction tuning makes responses more persistently conditioned on instruction spans, increases attention-head specialization for instruction verbs, and rotates FFN concept space toward user-oriented tasks such as writing and coding (Wu et al., 2023). “Does Instruction Tuning Make LLMs More Consistent?” then shows that instruction-tuned LLaMA models become more consistent in representations and predictions under paraphrastic perturbations, with MMLU accuracy spread dropping from 1.6 for base LLaMA-7B to between 0.2 and 1.1 for the ten instruction-tuned variants studied (Fierro et al., 2024). These papers together suggest that structural effects of instruction tuning are not only dataset-level phenomena; they also appear as changes in representational geometry and control flow.

A third misconception is that instruction-tuned models always outperform base models. The 2026 study on math and domain-shifted benchmarks shows that this is not generally true (Munjal et al., 19 Jan 2026). On GSM8K in zero-shot CoT, base models outperform instruction-tuned variants by as much as 32.67 points for Llama3-70B and 31.23 points for Kimi-K2. Under domain shift on MedCalc, base models often remain superior, and instruction-tuned models degrade sharply on Math Perturb Hard. The paper’s interpretation is that some instruction-tuning gains are contingent on prompt structure, few-shot exemplars, output schemas, and benchmark conventions rather than on structure-invariant reasoning.

The literature therefore converges on a cautious conclusion. Structural instruction tuning can improve pairwise coherence, curriculum efficiency, robustness, schema compliance, and modality transfer, but its successes depend on what kind of structure is imposed and what pathology is being corrected. Pairwise compatibility does not ensure truth; curricula do not replace data quality; schemas can improve controllability without solving reasoning; and explicit structure can still be exploited through shallow shortcuts. A plausible next step is to combine these strands more systematically: pairwise mutual alignment for data curation, ability- and coverage-aware dataset construction, explicit schema or modality structure where appropriate, and evaluation suites that separate semantic competence from output-format compliance and prompt-template sensitivity.