TagRouter: Learning Route to LLMs through Tags for Open-Domain Text Generation Tasks

Jianmin Wu; Xue Xiong; Yuqi Bai; Zhiqiang Wei; Zhou Chen

REVIEW 3 major objections 3 minor 9 references

TagRouter: Learning Route to LLMs through Tags for Open-Domain Text Generation Tasks

T0 review · 3 major / 3 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Routing by semantic tags lets cheaper models answer the queries they do best, outperforming any single LLM.

desk verdict Practical tag-based router with a clean idea, but the evaluation leans on a single judge and the headline gains are within noise. read the letter →

arxiv 2506.12473 v1 pith:CDOCNNKI submitted 2025-06-14 cs.CL

Zhou Chen , Zhiqiang Wei , Yuqi Bai , Xue Xiong , Jianmin Wu This is my paper

classification cs.CL

keywords modelroutinglargelanguagemodelstaggenerationcost-efficientinferenceopen-domaintextLLMensemblingacceptratetraining-free

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper proposes TagRouter, a model-routing method that decides which large language model should answer a query by first tagging the query and then looking up a tag-to-model score table. The central claim is that this tag-then-score procedure beats 13 existing routing methods and even beats always using the largest model: on a real user-query benchmark, TagRouter raises Accept Rate from 78.76% to 83.60% while lowering relative cost by about 17%. The method is designed to stay useful as the model ecosystem changes: adding a candidate model requires only a small set of pairwise judgments to fill in that model's tag scores, not retraining the router. If the claim holds, it offers a cheap way to assemble many LLMs into a system that behaves like a 'super model' without paying for the largest model on every query.

What carries the argument

The load-bearing object is the tag-score map stored in the TAGSCORER module: a key-value table that assigns each normalized tag $t$ and candidate model $M_i$ a score $$\mathrm{score}(M_i,t)=w_t\sum_{r\in\{\mathrm{win},\mathrm{tie},\mathrm{loss}\}}\mathrm{count}_{t,M_i}(r)\,s_r,$$ where the counts come from pairwise responses judged by EB4.0 and $w_t$ is a tag-frequency confidence weight. Around this table sit the TAGGENERATOR (a 0.5B model distilled from EB4.0 tags, with frequency filtering, rule aggregation, and PhraseBERT-based clustering to build a 1,601-tag vocabulary) and the TAGDECIDER (which sums the per-tag scores and applies a cost threshold $\theta$). The table is what makes the method training-free with respect to the candidate pool: a new model enters by annotating its tag scores, with no retraining of the router.

What would settle it

Take a held-out sample of 1,000 queries from BCUQ, run TagRouter with its tuned threshold, and label each response by a panel of human raters instead of EB4.0. If the Accept Rate under human labels does not exceed EB3.5's 78.76% by at least the reported margin, the routing gain is an artifact of the judge rather than a genuine quality gain.

Watch

Extended reading notes

Core claim

TagRouter's discovery is that routing can be performed in tag space rather than raw query space. A small distilled tag generator converts each query into a set of semantic tags; a tag-score table records, for each tag and candidate model, a score derived from the model's win/tie/loss record against the largest model; and the decider routes the query to $\operatorname{arg\,max}_{M} \sum_{t \in T(q)} \mathrm{score}(M, t)$, with a cost threshold $\theta$ that can redirect borderline queries to a cheaper model. On the BCUQ benchmark with EB3.5 as the reference model, TagRouter reaches an Accept Rate of 83.60% at the tuned threshold, a 6.15-point improvement over EB3.5, at a relative cost of 1.164, and it reports the highest AUC and PAUC among all baselines. It also reports consistent gains on the Alpaca and Dolly datasets and when routing between two similar-capability models, GLM4-9B and Qwen2.5-7B.

Load-bearing premise

The whole pipeline—the win/tie/loss counts that fill the tag-score table and the Accept Rate that measures success—is produced by a single LLM judge (EB4.0), so if that judge's preferences do not match human preferences, the reported 6.15-point gain could simply be the router getting better at pleasing the judge.

Editorial extensions

If this is right

On BCUQ, routing by tags raises the system's Accept Rate from 78.76% (always using the largest model) to 83.60%, and reaches a relative cost of 1.164, which the paper reports as a 17.20% cost reduction.
Tags carry routing-relevant signal beyond raw text: swapping raw queries for TAGGENERATOR tags lifts RouteLLM's matrix-factorization variant from 80.34% to 82.02% Accept Rate.
Scaling the model pool helps: AUC rises from 0.7610 with two candidate models to 0.8043 with five, so the method can absorb new LLMs as they appear.
The default cost threshold $\theta=0$ already gives above-reference-model performance at lower cost, and a small grid search for $\theta^*$ improves Accept Rate further on Alpaca, Dolly, and BCUQ.
A tag generator trained only on BCUQ still beats dataset-specific fine-tuned baselines on Alpaca and Dolly, and training on as few as 100 samples already improves Accept Rate by 0.86%.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A testable extension is to swap the trained 0.5B TAGGENERATOR for a general-purpose tagger at serving time; if the AUC gap stays small, the tag-score table, not the distilled generator, is the key contribution.
Because the tag-score table is additive per tag, it could be exposed as a production cost slider: lowering $\theta$ routes more queries to cheap models, and the AUC/PAUC curves quantify exactly what performance is traded per unit of cost.
The interpretable tag list (for example, 'Medical Report' strongly favors the small model) suggests the same table could be reused for model-strength dashboards or to choose which capability to improve when training the next model.
If human preference data were substituted for the EB4.0 labels in the tag-score table, the same pipeline would produce a router whose gains are measured against people rather than against a single judge, which would resolve the paper's reliance on one LLM judge.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The core idea here is simple and worth taking seriously: tag a query with a cheap model, look up each candidate model's average win/tie/loss score on those tags, and pick the best one. The distillation of an open tagger into a 0.5B model, plus the cost-aware threshold, is a useful engineering contribution. But the evaluation can't yet support the claim that this actually beats the baselines, because the same judge (EB4.0) that made the labels is the same judge that measures the outcome, and the reported gains are small.

What the paper does well: the method is clearly described, the ablations are thoughtful (tag normalization, alignment, scorer weights, tag generator size), and the generalization experiments to other datasets and model pairs are a nice touch. The tag-based abstraction is genuinely interesting and may help people think about routing in terms of capabilities rather than raw embeddings. The system is lightweight and practical: a 500MB tag generator plus a lookup table.

The biggest issue is the circularity of EB4.0. It generates the tags, produces the win/tie/loss labels for the tag-score table, and then acts as the judge for Accept Rate. That is a single point of failure. The 50-sample human validation with one author is too thin to rule out a systematic judge bias correlated with tag content. I don't think this is fatal—the method probably works—but the headline number should be treated as 'agreement with EB4.0' rather than 'quality improvement.' The paper's own Limitations section acknowledges the LLM-as-a-judge concern but relies on that same 50-sample check, which is statistically inadequate.

Second, the AR improvement over FORC is 1.8 percentage points on 890 queries, which is roughly one standard error. The AUC and PAUC differences are more substantial, but they come without any confidence intervals or bootstrap estimates. Third, ZOOTER, the closest tag-based prior work, is missing from the baselines, which weakens the SOTA claim. And the 'training-free' label is misleading since the tag generator is trained.

Who is this for? People building LLM routing systems who want a light-weight, interpretable method. It's not a home run, but it's a sensible design with a credible mechanism. I'd send it to review, but flag the evaluation. The paper needs an independent judge or a much larger human eval, uncertainty estimates, the ZOOTER baseline, and a clearer discussion of the 'training-free' phrasing. With those fixes, it could be a solid systems paper.

Referee Report

3 major / 3 minor

Summary. TagRouter is a training-free model routing method that first generates open-domain semantic tags for each query using a small distilled TAGGENERATOR (Qwen2.5-0.5B, trained on tags produced by ERNIE-4.0-Turbo-8K), then scores each candidate model per tag using pairwise win/tie/loss statistics collected by the same ERNIE-4.0 judge, and finally selects a model with a cost-aware threshold. Experiments on the Baidu Cloud User Queries (BCUQ) benchmark and on Alpaca and Dolly claim consistent improvements over 13 baselines, reaching 83.60% Accept Rate at the tuned threshold on BCUQ (a 4.84 percentage point gain over always routing to ERNIE-3.5-8K) while reducing cost to 1.164 relative cost. The paper also studies scaling to five candidate models and generalization to unseen datasets and model pairs.

Significance. If the empirical claims survive scrutiny, TagRouter offers a practical and efficiently deployable routing mechanism in a fast-moving LLM ecosystem: the tagger is 0.5B parameters, routing is a key-value lookup, and new models are added by collecting tag-score pairs without retraining. The detailed algorithms, prompt templates, and ablation tables make the method re-implementable. However, the paper’s central evidence that TagRouter improves response quality is weakened by the fact that ERNIE-4.0 serves simultaneously as the tag generator, the pairwise judge that defines the tag-score table, and the evaluator of the reported Accept Rate. The only human validation is 50 samples annotated by one of the authors, and no confidence intervals or significance tests accompany the headline comparisons. These are load-bearing limitations for a paper whose primary contribution is an empirical performance improvement.

major comments (3)

[Sec. 3.3, Sec. 4, Appx. C.2] The win/tie/loss labels that define the TAGSCORER table (Sec. 3.3) and the Accept Rate metric used in all experiments (Sec. 4) are both produced by EB4.0, which also generates the raw tags used to train TAGGENERATOR (Sec. 3.2). This creates a circular pipeline: TagRouter is explicitly optimized to predict EB4.0's preferences on held-out queries. The only human check is 50 samples with one author as annotator (Appx. C.2, Tab. 5), reporting an aggregate Cohen's kappa of 0.79 without per-tag agreement. The reported gain of 4.84 percentage points in Accept Rate (83.60% vs. 78.76%) is small enough that a systematic judge bias correlated with tag content could account for it. Please provide an independent judge (e.g., GPT-4 or a larger human sample with multiple annotators) for at least the BCUQ test set, or report per-tag agreement, to show that the routing preference reflects human quality rather than judge artifacts.
[Sec. 5.2.1, Tab. 2] No confidence intervals, bootstrap estimates, or significance tests are reported for any of the main results. On the BCUQ test set of 890 queries, the difference between TagRouter (83.60) and the strongest baseline FORC (81.80) is 1.80 percentage points; given the test-set size, the standard error of a proportion near 0.83 is about 1.2 percentage points, so this difference is only about one standard error. Please report confidence intervals for the key AR/AUC numbers and, where possible, test whether the improvement over the best baseline is statistically significant. Without this, the claim that TagRouter 'outperforms all baselines' is not supported at the reported level of precision.
[Sec. 5.2.3, Fig. 3] The scalability experiment in Fig. 3 compares two, three, and five candidate models, but the AUC values are point estimates on a fixed test set with no error bars. The reported AUC increases from 0.7610 to 0.7933 to 0.8043, yet it is unclear whether the differences across model-set sizes are meaningful given the test-set size and the lack of repeated evaluations. Please add confidence intervals or at least specify how sensitive these AUC values are to the 890-query test set.

minor comments (3)

[Abstract and Sec. 1] Typographical issues: 'Our findings provides' should be 'Our findings provide'; 'a evolvable' should be 'an evolvable'; 'exising' in Sec. 5.2.1 should be 'existing'; 'brainstroming' in Sec. 5.2.2 should be 'brainstorming'; 'Accuarcy' in Tab. 9 header should be 'Accuracy'.
[Sec. 2.3 and Tab. 4] The BCUQ test set size is 890 queries, and the validation set is 1,000. Please state explicitly that the threshold θ and other hyperparameters were tuned only on the validation set, and that the reported 'Performance at Max AR' numbers are on the test set. The current phrasing in Sec. 5.1 and Appx. C.3 is ambiguous.
[Sec. 6, 'How practical is TagRouter?'] The sentence 'Tab. 7 presents the performance under varying sample sizes' is ambiguous: Tab. 7 shows training data size for TAGGENERATOR, not the sample size for annotating new candidate models. Please clarify which table supports the claim about adding new models.

Circularity Check

0 steps flagged · score 0.0 of 10

No derivation-chain circularity: the EB4.0 judge loop is an evaluation-validity limitation, not a circular reduction.

full rationale

The claimed derivation chain is: EB4.0 generates query tags (Sec. 3.2), the TAGGENERATOR is distilled to imitate those tags, EB4.0 pairwise judgments populate the TAGSCORER table (Sec. 3.3), the TAGDECIDER routes by argmax over tag scores (Sec. 3.4), and the Accept Rate is computed from EB4.0 win/tie labels (Sec. 4, Appx. C.2). This is a closed loop in the sense that the same judge supplies the tags, the training labels, and the evaluation metric. However, the test set is held out: the tag-score table is fitted on training queries, while AR is measured on a separate test split. The routing decision is therefore not evaluated on the same examples used to build the table, so the reported improvement is not an identity or a numerically forced fit. The baseline methods are also trained and evaluated under the same EB4.0-based AR, making the relative comparison symmetric. The paper explicitly acknowledges that LLM-as-a-judge may be less reliable than human evaluation and provides a 50-sample human consistency check (Tab. 5), albeit with one author as annotator; this is a genuine external-validity weakness, but it is a correctness risk rather than a circular reduction. No equation in the paper is equal to another equation by construction, and no load-bearing claim rests on a self-citation: the authors' prior works (Chen et al. 2024b, 2025a-c) appear only as background citations. Accordingly, the paper's central derivation is self-contained against its stated metric and benchmarks, and the circularity score is 0.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The method introduces no new physical or conceptual entities; tags are generated text labels, and the tag-score table is a standard lookup structure. The main unstated assumptions are the reliability of the LLM judge and the sufficiency of tags as routing features.

free parameters (3)

stie = 0.15
Tie score weight in the tag-score mapping, grid-searched on BCUQ validation (Fig. 12).
alpha (data sampling ratio) = 0.10
Sampling ratio for training TAGGENERATOR, chosen by consistency and diversity on BCUQ validation (Tab. 8).
theta (cost-aware threshold) = 0 default; theta* grid-searched per dataset
Controls the tradeoff between cost and performance. The headline BCUQ result uses theta* chosen on a 1,000-sample validation set (Sec. G.2).

assumptions (4)

domain assumption EB4.0's pairwise win/tie/loss judgments are a reliable proxy for human response quality.
Used to build the TAGSCORER table (Sec. 3.3) and to compute the Accept Rate (Sec. C.2). Human validation is limited to 50 samples with one author annotator.
ad hoc to paper Semantic tags of a query are sufficient statistics for predicting which candidate model will produce the best response.
Central inductive bias of the routing function f(T(q), M) in Sec. 2.2. No theoretical justification is provided.
domain assumption PhraseBERT embeddings with cosine similarity adequately align arbitrary generated tags to the normalized tag set.
Used in the tag alignment step of TAGSCORER (Sec. 3.3). Ablation shows only a marginal AUC effect of 0.0001 after normalization (Fig. 11).
domain assumption The tag generator trained on BCUQ queries generalizes to other query distributions such as Alpaca and Dolly.
TAGGENERATOR is trained only on BCUQ (Sec. 3.2). Generalization to other datasets is tested empirically but not guaranteed.

how reviews work

0 comments

Cite this review

Pith. "Pith review of TagRouter: Learning Route to LLMs through Tags for Open-Domain Text Generation Tasks." pith.science (2026). https://pith.science/paper/CDOCNNKI

@misc{pith2026250612473,
  author       = {Pith},
  title        = {Pith review of: TagRouter: Learning Route to LLMs through Tags for Open-Domain Text Generation Tasks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/CDOCNNKI}},
  note         = {Machine review of arXiv:2506.12473}
}

read the original abstract

Model routing allocates queries to the suitable model, improving system performance while reducing costs. However, existing routing methods face practical limitations that hinder scalability in large-scale applications and struggle to keep up with the rapid growth of the large language model (LLM) ecosystem. To tackle these challenges, we propose TagRouter, a training-free model routing method designed to optimize the synergy among multiple LLMs for open-domain text generation tasks. Experimental results demonstrate that TagRouter outperforms 13 baseline methods, increasing the accept rate of system by 6.15% and reducing costs by 17.20%, achieving optimal cost-efficiency. Our findings provides the LLM community with an efficient and scalable solution for model ensembling, offering users an evolvable "super model."

Figures

Figures reproduced from arXiv: 2506.12473 by the authors.

**Figure 1.** Overview of TAGROUTER. The training phase is represented in blue, and the inference phase in green. TAGROUTER consists of three modules: TAGGENERATOR, TAGSCORER, and TAGDECIDER, which are invoked sequentially. First, TAGGENERATOR generates fine-grained tags for each query. Next, TAGSCORER evaluates the performance of different models on the query by computing scores based on these tags. Finally, TAGDECIDER selects t… view at source ↗

**Figure 2.** Comparison of TAGROUTER and the top three ranking existing routing methods across eight task categories in BCUQ dataset. The ratio to EB3.5 represents the proportion of queries routed to EB3.5, where a higher ratio implies increased cost within the system. TAGROUTER outperforms baselines across most tasks. formance remains comparable to that of random routing. This could be attributed to the structured nature of QA … view at source ↗

**Figure 3.** Scalability of TAGROUTER. Performance improves with more candidate models (from two to three to five), with enhanced AUC and cost-efficiency. the threshold setting θ = 0, while simultaneously reducing costs. These findings suggest that increasing the number of candidate models not only boosts performance but also improves cost-efficiency. 5.2.4 Ablation Study We conduct an ablation study on each component within ev… view at source ↗

Figures from the paper (9 more)

**Figure 4.** Figure 4: Task distribution in BCUQ. shows the distribution of task types in BCUQ dataset. The classification of tasks is as follows: Brainstorming: This task focuses on generating creative ideas or solutions to stimulate innovation. Classification: This task involves the automa…

**Figure 5.** Figure 5: Performance comparison of TAGROUTER and the baseline methods on BCUQ dataset. TAGROUTER outperforms all baselines. (a) Comparison between TAGROUTER and the top three existing routing methods. (b) Comparison between TAGROUTER and other tag-based routing methods introduc…

**Figure 6.** Figure 6: Performance of TAGROUTER on BCUQ dataset. The candidate LLMs are GLM4-9B and Qwen2.5-7B. "w/ original TAGSCORER" denotes the use of tag-score pairs generated by EB3.5 and EBspeed as capability representations, while "w/ enhanced TAGSCORER" refers to the use of tag-sco…

**Figure 7.** Figure 7: Performance of TAGROUTER on Alpaca and Dolly datasets. Candidate models include EB3.5 and EBspeed. "w/ original TAGSCORER" refers to routing based solely on tag-scores computed from the BCUQ dataset, whereas "w/ enhanced TAGSCORER" incorporates tag-scores computed from…

**Figure 8.** Figure 8: Performance comparison of TAGROUTER and the top three ranking existing routing methods on Alpaca and Dolly datasets. TAGROUTER outperforms all baselines. of TAGROUTER as a training-free routing method. Furthermore, [PITH_FULL_IMAGE:figures/full_fig_p017_8.png]

**Figure 9.** Figure 9: Win/Tie/Loss distribution for the top 10 tags. [PITH_FULL_IMAGE:figures/full_fig_p021_9.png]

**Figure 10.** Figure 10: Win/Tie/Loss distribution for the bottom 10 tags. [PITH_FULL_IMAGE:figures/full_fig_p021_10.png]

**Figure 11.** Figure 11: Impact of tag normalization and tag align [PITH_FULL_IMAGE:figures/full_fig_p023_11.png]

**Figure 13.** Figure 13: Performance of TAGROUTER on the Alpaca, Dolly, and BCUQ datasets for various values of θ. Dataset θ Performance at Max AR AR(%)↑ Uplift(%)↑ Cost↓ Rank↓ Alpaca θ=0 82.49 1.25 12.81 1.175 θ=θ ∗ 86.64 6.35 12.63 1.166 Dolly θ=0 86.67 4.68 15.34 1.131 θ=θ ∗ 86.86 4.91 14.…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

9 extracted references · 5 canonical work pages

[1]

The extracted keywords should represent the core intent of the sentence

work page
[2]

The output should strictly follow the required format without any unrelated text

work page
[3]

One-Stop Website Solutions

Only output the required JSON format, without using markdown formatting. Input content: What should I do if I catch a cold? Keyword Extraction, Out- put Formatting, Text Pro- cessing You are a master of marketing copy, tasked with creating a catchy slogan for a product named "One-Stop Website Solutions." The product’s strengths are professionalism, ease, ...

work page
[4]

In Proceedings Of The 17Th Acm International Conference On Web Search And Data Mining, Wsdm 2024 , pages 606–

Fly-swat or cannon? cost-effective language model choice via meta-modeling. In Proceedings Of The 17Th Acm International Conference On Web Search And Data Mining, Wsdm 2024 , pages 606–

work page 2024
[6]

13 shows the performance of the model system across various values of θ

Fig. 13 shows the performance of the model system across various values of θ. Experiments conducted on three datasets demonstrate that the default setting of θ = 0 is an satisfactory choice. In this configuration, the model system not only outperforms any individual model in AR score, but also incurs lower costs compared to the method of Query Tag Transla...

work page
[615]

w/ original TAGSCORER

Assoc Computing Machinery. Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. 2020. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. Preprint, arXiv:1910.01108. Junhong Shen, Neil Tenenholtz, James Brian Hall, David Alvarez-Melis, and Nicolò Fusi. 2024. Tag- llm: repurposing general-purpose llms for special- ized ...

arXiv 2023
[2021]

In International Conference on Learning Representations

Measuring massive multitask language under- standing. In International Conference on Learning Representations. Edward J Hu, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen, et al. 2021. Lora: Low-rank adaptation of large lan- guage models. In International Conference on Learn- ing Representations. Qitian Jason Hu, Jacob Biek...

arXiv 2021
[2023]

In International Conference on Machine Learning, pages 19274–19286

Fast inference from transformers via spec- ulative decoding. In International Conference on Machine Learning, pages 19274–19286. PMLR. Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Hein- rich Küttler, Mike Lewis, Wen-tau Yih, Tim Rock- täschel, et al. 2020. Retrieval-augmented generation for knowledge-inten...

arXiv 2020

Show all 9 references

[2024]

arXiv preprint arXiv:2405.02134

Optimising calls to large language models with uncertainty-based two-tier selection. arXiv preprint arXiv:2405.02134. Marija Sakota, Maxime Peyrard, Robert West, et al

arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

The extracted keywords should represent the core intent of the sentence

work page

[2] [2]

The output should strictly follow the required format without any unrelated text

work page

[3] [3]

One-Stop Website Solutions

Only output the required JSON format, without using markdown formatting. Input content: What should I do if I catch a cold? Keyword Extraction, Out- put Formatting, Text Pro- cessing You are a master of marketing copy, tasked with creating a catchy slogan for a product named "One-Stop Website Solutions." The product’s strengths are professionalism, ease, ...

work page

[4] [4]

In Proceedings Of The 17Th Acm International Conference On Web Search And Data Mining, Wsdm 2024 , pages 606–

Fly-swat or cannon? cost-effective language model choice via meta-modeling. In Proceedings Of The 17Th Acm International Conference On Web Search And Data Mining, Wsdm 2024 , pages 606–

work page 2024

[5] [6]

13 shows the performance of the model system across various values of θ

Fig. 13 shows the performance of the model system across various values of θ. Experiments conducted on three datasets demonstrate that the default setting of θ = 0 is an satisfactory choice. In this configuration, the model system not only outperforms any individual model in AR score, but also incurs lower costs compared to the method of Query Tag Transla...

work page

[6] [615]

w/ original TAGSCORER

Assoc Computing Machinery. Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. 2020. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. Preprint, arXiv:1910.01108. Junhong Shen, Neil Tenenholtz, James Brian Hall, David Alvarez-Melis, and Nicolò Fusi. 2024. Tag- llm: repurposing general-purpose llms for special- ized ...

arXiv 2023

[7] [2021]

In International Conference on Learning Representations

Measuring massive multitask language under- standing. In International Conference on Learning Representations. Edward J Hu, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen, et al. 2021. Lora: Low-rank adaptation of large lan- guage models. In International Conference on Learn- ing Representations. Qitian Jason Hu, Jacob Biek...

arXiv 2021

[8] [2023]

In International Conference on Machine Learning, pages 19274–19286

Fast inference from transformers via spec- ulative decoding. In International Conference on Machine Learning, pages 19274–19286. PMLR. Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Hein- rich Küttler, Mike Lewis, Wen-tau Yih, Tim Rock- täschel, et al. 2020. Retrieval-augmented generation for knowledge-inten...

arXiv 2020