ETLCH: Compact Structured Extraction Model

• ETLCH is a low-resource, multi-task model that extracts structured data in formats like JSON, knowledge graphs, and named entity recognition.
• It utilizes a 1B-parameter LLaMA-based architecture with LoRA, enabling efficient fine-tuning on minimal data and deployment on a single RTX 3090.
• The model outperforms larger baselines by achieving competitive extraction accuracy and >96% valid JSON generation, ensuring robust downstream automation.

ETLCH is a billion-parameter LLaMA-based model fine-tuned for low-resource, multi-task structured information extraction, with task coverage spanning JSON extraction, knowledge graph extraction, and named entity recognition. It is presented as a compact alternative for settings in which large architectures and large annotated corpora are impractical, and its reported performance emphasizes syntactic reliability, especially strict JSON generation, alongside competitive extraction accuracy against substantially larger instruction-tuned baselines (Chih et al., 10 Sep 2025).

1. Scope, designation, and research setting

ETLCH denotes a LLM for structured information extraction rather than an Extract-Transform-Load orchestration system. In the cited work, it is introduced for domains such as financial compliance reporting, legal document analytics, and multilingual knowledge base construction, where deployment of LLMs is often constrained by compute cost and the difficulty of preparing large, high-quality datasets (Chih et al., 10 Sep 2025).

The model is explicitly framed for low-resource, multi-task conditions. The paper states that most recent instruction-tuning studies focus on seven-billion-parameter or larger models, leaving limited evidence on whether much smaller models can work reliably under low-resource settings. ETLCH addresses that gap by using a 1B-parameter base model and fine-tuning it on only a few hundred to one thousand samples per task. The central claim is not merely that a small model can function, but that, when carefully adapted, it can produce stable structured outputs suitable for downstream automation.

The task formulation is deliberately narrow and operational. ETLCH is trained jointly on three extraction formats: JSON extraction, knowledge graph extraction, and named entity recognition. This choice reflects a downstream orientation: outputs are expected to be machine-consumable, schema-constrained, and robust enough for inclusion in information extraction pipelines.

2. Model architecture and adaptation strategy

ETLCH is built on Llama-3.2-1B-Instruct, described as a 1B-parameter LLaMA-based model, and is fine-tuned with Low-Rank Adaptation (LoRA) applied to the attention weights (Chih et al., 10 Sep 2025). The paper emphasizes practicality: the model is trained in full precision, without quantization, because of the small model size, and the full fine-tuning workflow is reported to run on a single RTX 3090 GPU.

The reported LoRA configuration is specific: rank $r = 32$, dimension $a = 64$, dropout $0.4$ on the adapters, batch size $2$, learning rate $1 \times 10^{-7}$, gradient norm clipped at $0.1$, and 100 epochs per setting. The paper characterizes the dropout and small batch size as anti-overfitting measures suited to tiny training sets.

The low-rank update is expressed in the paper as

$\Delta W = BA$

with $B \in \mathbb{R}^{d \times r}$, $A \in \mathbb{R}^{r \times k}$, and $r \ll \min(d,k)$. The adapted weight matrix is written as

$a = 64$0

where $a = 64$1 is the base attention weight and $a = 64$2 is the adaptation scaling. In the context of ETLCH, this formulation is important because the paper’s broader argument depends on parameter-efficient tuning rather than full-model retraining. The model’s practical identity is therefore inseparable from its adaptation regime: ETLCH is not only a small base model, but a small model whose trainable footprint is deliberately constrained.

3. Multi-task instruction tuning and data design

The instruction-tuning setup is multi-task and multi-instruction. All three tasks—JSON extraction, knowledge graph extraction, and named entity recognition—are trained jointly, and the paper states that this joint setup leverages inter-task dependencies for both supervision and error correction (Chih et al., 10 Sep 2025). It gives a concrete consistency intuition: entities found in named entity recognition should align with graph nodes in knowledge graph extraction, while JSON structure imposes output constraints across both.

Each training sample is described as having three components. First, it includes a long, semantically dense context, up to approximately 1500 tokens, generated with ChatGPT (gpt-4o-mini) and spanning diverse domains. Second, it includes a task-specific instruction, designed both for the model and for annotation. Third, it includes a reference output, generated with ChatGPT and then post-processed into strict target formats. For JSON extraction, outputs are required to be list-valued; for knowledge graph extraction, outputs must be subject-relation-object triples.

The paper’s main linguistic focus is Chinese-language text and instructions, although English paraphrases are provided for clarity. This is relevant to both performance interpretation and model positioning. ETLCH is not presented as a generic multilingual benchmark model; rather, it is evaluated in a specific low-resource, Chinese-centric structured extraction regime.

The three task families have distinct output semantics. Named entity recognition extracts key entities and returns them as JSON. Knowledge graph extraction produces a flat list of triples. JSON extraction parses structured content into machine-readable JSON according to a schema. The training objective is therefore not just sequence generation, but structured output formation under multiple concurrent format constraints.

4. Evaluation protocol and comparison framework

The evaluation uses held-out ChatGPT-generated data for both contexts and task instructions. The baseline set comprises three larger instruction-tuned models: Qwen2.5-7B, described as Chinese-centric; Breeze-7B, described as a large local LLM fine-tuned for Taiwanese use cases; and Taide-8B, described as a Taiwan-localized LLaMA-3-8B-based model (Chih et al., 10 Sep 2025).

Three evaluation metrics are reported. ROUGE-L (F1) is used as a Longest Common Subsequence-based comparison capturing lexical and structural precision and recall. Cosine similarity is used to compare embedding-level similarity between generated and reference outputs. JSON parse validity measures whether a generated string is syntactically valid JSON, which the paper treats as operationally critical because invalid JSON can break downstream automation even when semantic content is partially correct.

The paper also reports statistical significance using t-tests and z-tests. For JSON extraction and knowledge graph extraction, ETLCH’s gains over the baselines are reported as having p-values $a = 64$3. For named entity recognition, the paper states that ETLCH slightly outperforms Qwen2.5-7B, but that the difference is not always statistically significant, with $a = 64$4 in some comparisons.

This evaluation design places unusual weight on output validity. In many extraction studies, exact parsing success is secondary to approximate semantic match. In ETLCH, by contrast, parse validity is treated as a first-order property because the target use case is automated structured extraction rather than free-form summarization.

5. Reported empirical performance

The paper reports that ETLCH achieves the strongest results across most of the reported metrics despite its smaller scale (Chih et al., 10 Sep 2025). The most salient pattern is that the 1B model surpasses the 7B and 8B baselines not only on similarity-based metrics but also on strict syntactic validity.

Task or metric	ETLCH	Best baseline shown
ROUGE-L (F1), JSON	0.69	0.58
ROUGE-L (F1), KGE	0.68	0.56
ROUGE-L (F1), NER	0.60	0.58
Cosine similarity, JSON	0.92	0.82
Cosine similarity, KGE	0.90	0.85
Cosine similarity, NER	0.88	0.82
Valid JSON string rate	>96%	0.0%

The reported baselines in the table above correspond to the strongest among the cited larger models for each metric; the paper also reports lower values for Breeze-7B and Taide-8B. The validity result is especially notable: ETLCH is reported to generate syntactically valid JSON at a rate of more than 96%, whereas all three larger baselines are reported as producing 0.0% parseable outputs under the strict evaluation scripts.

The paper also emphasizes data efficiency. The largest improvements are reported between 100 and 300 samples per task, with diminishing returns above 500–1000 samples. A specific example is given for valid JSON count: approximately 144/300 at 100 samples, 267/300 at 300 samples, and approximately 288/300 after 1000 samples. This is used to support the claim that ETLCH can reach saturated or near-saturated performance with only a few hundred annotations per task.

Across all tasks, metrics, and data scales, the paper reports that ETLCH matched or beat much larger models in 70–100% of comparisons. The strongest gains are reported for JSON extraction and knowledge graph extraction, while named entity recognition shows a narrower margin over Qwen2.5-7B.

6. Significance, applications, and interpretive boundaries

The practical significance assigned to ETLCH is concentrated in resource-constrained environments. The paper explicitly connects the model to SMEs, privacy-critical edge deployments, and domain-adapted settings such as finance, legal, and healthcare (Chih et al., 10 Sep 2025). Its central proposition is that a carefully tuned small model can deliver structured outputs with enough stability and formal correctness to serve as a component in automated extraction workflows.

Two aspects of the work are particularly important for that claim. The first is compute practicality: a 1B model fine-tuned with LoRA on a single consumer GPU has a very different deployment profile from a 7B or 8B model. The second is output reliability: the paper repeatedly stresses that valid structure, especially parseable JSON, is as important as semantic correctness because downstream ETL-style automation depends on syntactic compliance.

The paper’s broader interpretation is that small models plus careful multi-task LoRA fine-tuning can outperform large models for structured information extraction given limited data and compute. This is framed not as a universal rule for all language tasks, but as an empirical result for a narrowly defined family of structured extraction problems.

At the same time, the evidentiary scope is specific. The reported experiments focus primarily on Chinese-language tasks, and both training and test data are based on ChatGPT-generated contexts and instructions. A plausible implication is that broader generalization to externally curated corpora, noisier real-world documents, or substantially different linguistic distributions would require separate validation. Within the reported setting, however, ETLCH is presented as evidence that small instruction-tuned models can be competitive when the target task is structured extraction rather than open-ended generation.

ETLCH therefore occupies a distinct position in the recent literature on information extraction. It is not introduced as a general-purpose foundation model, nor as an orchestration framework for data pipelines. Instead, it is a compact, LoRA-adapted extraction model whose contribution lies in demonstrating that strict structured output generation can be made accurate, data-efficient, and operationally reliable without reliance on large-scale models (Chih et al., 10 Sep 2025).