acceptodds
Under review as a conference paper at ICLR 2027

Routing Starts with Representation: Behavioral Query Pretraining for LLM Routers

Abstract

Large language models (LLMs) vary substantially in capability, making model routing a promising approach to improving inference efficiency by selecting an appropriate model for each query. Existing work has largely focused on designing more capable routers, while treating the query representation as a fixed input from a general-purpose text encoder. We show that this assumption is limiting: semantic query geometry is systematically misaligned with the behavioral geometry relevant to routing. Motivated by this observation, we introduce behavioral query pretraining, which uses historical query–model interactions to fine-tune a query encoder with multi-model supervision and then discards the prediction head, yielding a reusable routing-aware representation. Across diverse frozen-query routing methods, the resulting representation consistently improves routing performance and is effective under limited target supervision.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM, Model selection, text embedding

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_sKmkOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper fine-tunes a query encoder to predict correctness across multiple source LLMs, then discards the prediction head and reuses the frozen encoder with downstream routers. Experiments on EmbedLLM report improvements across eight routing variants and several target-supervision budgets. Transfer to RouterBench also improves the reported quality–cost tradeoff. The main contribution is a reusable representation learned from historical model outcomes, with no candidate-model probing at inference time.

Critical strengths

Learning the representation once and reusing it across downstream routers is a useful practical direction. It moves the additional work into training and preserves a simple inference pipeline that calls only the selected LLM.

Critical weaknesses
  1. The main experiments are limited to EmbedLLM, with external transfer tested only on RouterBench. Prior analysis finds that routers on RouterBench tend to favor globally strong models, so gains there do not by themselves establish transferable, query-specific routing ability. Evaluation on another benchmark such as SPROUT/CARROT, together with best-single-model and cost-matched static baselines, is needed to substantiate the claim of a broadly reusable encoder.
  2. KNN's weak performance needs explanation. In Table 2, Raw KNN achieves 59.82%, versus 64.66% for logistic regression, whereas The Routing Plateau and Rethinking Predictive Modeling for LLM Routing find KNN highly competitive. Different model pools or data splits could explain this discrepancy, but the paper neither reconciles these differences nor specifies KNN's neighborhood-size selection and tie-breaking. This leaves uncertainty about baseline quality and whether the reported benefits persist against a well-tuned KNN router.
Questions for authors
  1. On RouterBench, what gains remain over a validation-selected best single model and query-independent model mixtures at matched cost? This would help establish whether transfer improves query-specific decisions rather than mainly recovering global model preferences. Can you demonstrate frozen-encoder transfer on another benchmark, such as SPROUT/CARROT, using the same strong baselines and a verified separation between source training and target test data?
  2. Why does KNN substantially underperform the learned routers in Table 2, given its strong performance in The Routing Plateau and Rethinking Predictive Modeling for LLM Routing? Please reconcile the model pools and splits and report KNN's neighbor count, validation search, similarity metric, and tie-breaking. Do the ranking and behavioral-pretraining gains persist against a well-tuned KNN baseline under your exact setup?
  3. What is the intuition for why predicting correctness on a particular source-model pool should produce a broadly reusable query representation? Two queries with similar source-model outcomes may have different preferences under another pool or query distribution. What general query properties does the objective learn beyond source-pool-specific patterns?
2 comments

Thank you for carefully reading our work and for raising these concrete questions. We added query-independent static baselines, held-model transfer, strict family-holdout tests, and a full KNN protocol audit. We respond point by point below.


W1 + Q1 — Does RouterBench transfer reflect query-specific routing?

Yes. Query-dependent routing clearly outperforms query-independent static strategies, and Behavior adds a further representation gain.

We add two static baselines: (B1) a validation-selected best single model, and (B2) a query-independent static mixture optimized under the same cost constraint. To ensure fairness, B1/B2 are re-solved at each router's realized average cost.

Their NQCA values are nearly identical:

  • LogReg range: B1 0.7111 / B2 0.7110
  • KNN range: B1 0.6943 / B2 0.6942
  • MLP range: B1 0.7062 / B2 0.7061

By comparison, Table 4 reports Behavior NQCA of 0.7617 / 0.7617 / 0.7624 for LogReg / KNN / MLP. Under matched-cost comparison, Behavior exceeds B2 by +0.0538 / +0.0586 / +0.0567 average quality, positive at all 30/30 operating points for each router.

Thus, RouterBench gains cannot be explained by selecting a globally strong model or a fixed model mixture; the main gain comes from query-specific model selection.

The representation also transfers beyond one model pool. Replacing the 89 seen models with 23 held-out models whose outcomes were never used in pretraining still gives +0.0304 macro AUC / +0.0108 reward for Behavior−Raw. Strict leave-MMLU-out training also gives 0.6072 AUC vs. 0.5818 Raw (+0.0254) on held-out MMLU.


W2 + Q2 — Why is KNN weaker than learned routers?

KNN is validation-tuned, and the Behavior gain remains significant; the weaker result is specific to top-1 selection in our 89-model binary-outcome setting.

Our KNN uses L2-normalized embeddings, cosine similarity, validation search over k ∈ {4,...,256}, and selects k=128. Candidate-model scores are the mean binary outcomes of the top-k neighbors.

Neighbor selection uses np.argpartition, while final model selection uses np.argmax, which returns the first maximum. AUC uses rankdata(method="average"), so ties receive average ranks.

Because EmbedLLM outcomes are binary, KNN scores lie on {0,1/k,...,1}. With 89 candidate models, neighborhood averaging produces a coarse score grid, making top-1 selection more tie-sensitive. Accordingly, Behavior KNN reaches 0.7251 macro AUC, compared with 0.7441 for LogReg; the ranking gap is much smaller than the reward gap.

Most importantly, under this tuned KNN protocol, Behavior−Raw still reaches +0.0288 macro AUC [0.0235,0.0357]. Therefore KNN's lower absolute reward does not explain the behavioral-pretraining gain.


Q3 — Why can correctness on one source-model pool produce a reusable query representation?

The source models act as diverse capability probes: their joint success/failure pattern reveals which properties of a query make different models succeed, rather than merely identifying which source model is best.

The key is that supervision comes from the full outcome vector, not a source-model ID. If two queries induce similar success/failure patterns across many heterogeneous models, they are likely to share properties that affect model capability—for example difficulty or the type of knowledge required. These query-side properties can remain useful even when the candidate models change.

Our transfer results directly test this interpretation. Behavior−Raw macro AUC is +0.0260 on the 89 source models and +0.0304 on 23 held-out models whose outcomes were never used in encoder pretraining. Thus the gain does not depend on reusing the source-model identities. It also survives query-distribution shift: after removing all MMLU text and behavior from encoder training, Behavior still achieves 0.6072 vs. 0.5818 AUC (+0.0254) on held-out MMLU.

The transferable signal is also richer than scalar difficulty. A difficulty-only neighborhood reaches only 0.605–0.610 pair-preference agreement, versus 0.775–0.796 for behavioral neighborhoods. Moreover, Full−Difficulty grows to +0.0044 / +0.0035 AUC in the highest model-disagreement regions and is near zero when models behave similarly.

Together, these results support a concrete interpretation: behavioral pretraining uses the source pool to expose query properties that predict differences in model success. Because those properties belong to the query rather than to a fixed model identity, the resulting representation remains useful for new model pools and new query families.

Reviewer_sKmkOpenReview ↗

Thank you for the reply!

My question still stands:

  1. What is the margin of uncertainty around the increase in routing reward of +0.0108 and the quality correction improvement through the use of the Behavior-Raw routing method?

  2. The confidence intervals are calculated based on the macro AUC for the KNN method. Is there any concrete evidence that supports the lower routing reward for the KNN method, which is attributed to the ties problem?

Reviewer_9rnXOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies query representations for LLM routing. It adapts Qwen3-Embedding-0.6B with LoRA and multi-label binary cross-entropy to predict which source models answer each query correctly. The prediction head is then discarded, and the frozen encoder supplies representations to different downstream routers. A diagnostic experiment first uses observed model outcomes to show that semantically similar queries need not induce similar model preferences. The authors then compare eight routers and several target-supervision budgets on EmbedLLM, and evaluate quality–cost performance on RouterBench. The main tables report improvements in average routing performance, while a linear probe shows that coarse task information remains recoverable. The central contribution is to separate query-encoder adaptation from a particular router and examine whether the resulting representation can be reused.

Critical strengths
  1. Replacing the representation produces positive results across different routers. With embedding dimensionality, downstream architecture, and training protocol held fixed, all eight routers improve in mean routing reward, with a maximum gain of 0.0283. This supports query representation as a worthwhile component to improve.

  2. The motivating experiment is well targeted. Neighborhoods constructed from one model pool's correctness records are evaluated for preference agreement on a disjoint pool, increasing agreement from 0.618 to 0.783 with uncertainty analysis. This supports using historical behavior to inform representation learning.

Critical weaknesses
  1. Key transfer and cost protocols are insufficiently specified. The candidate pools in Tables 2–3 are unclear, model/query overlap checks for RouterBench are not described, and neither pre-call affordability nor NQCA is precisely defined. These details directly affect the interpretation of cross-model transfer and practical cost savings.

  2. The specific value of multi-model supervision is not isolated. The main control is the unadapted encoder, without difficulty-prediction or existing routing-representation objectives trained on the same data and budget. It therefore remains unclear whether preserving individual models' success/failure patterns is necessary, or whether more general difficulty adaptation would provide similar gains.

Questions for authors
  1. Do Tables 2–3 route among the 23 held-out models, the 89 source models, or all 112? How are the K target queries sampled, and does the budget include validation supervision? Please also specify the source/target model identities and versions, query splits, and cross-benchmark overlap checks used for RouterBench.

  2. With the same source data, encoder, and LoRA training budget, how does predicting only average correctness per query, or using an existing routing-representation objective, perform? Please compare frozen representations on target routing and report uncertainty in paired differences to establish the additional value of individual model outcomes.

  3. Is an “affordable model” determined using costs known or predicted before the call, or its recorded realized generation cost? Please define NQCA, its integration and normalization ranges, and operating-point selection. If affordability uses post-call costs, please additionally evaluate a rule available before invocation and report uncertainty in the cost gains.

  4. The six displayed rows in Table 4 imply a mean Behavior score of approximately 0.7603 and a mean gain of 0.0021, rather than the reported 0.7607 and 0.0025. Does the Average row use a different aggregation, or is this a reporting error that needs correction?

2 comments

Response to Reviewer 9rnX

Thank you for the review. We add held-model transfer, matched-budget supervision controls, cross-benchmark overlap audits, and deployable pre-call affordability rules. We address each point below.


W1 + Q1 — Candidate pool, K-budget, and transfer protocol

Tables 2–3 use the 89 seen models and unseen queries; Table 3 is a new-query low-supervision setting.

Behavioral pretraining uses q_train × 89 seen-model outcomes. Table 2 evaluates q_test on the same 89-model pool. Table 3 keeps the candidate pool fixed and varies only the number K of labeled queries used to train the downstream router.

We additionally evaluate frozen transfer to 23 held-out models and all 112 models. For the 89 seen / 23 held / 112 all pools, Behavior−Raw is:

  • Reward: +0.0131 / +0.0108 / +0.0129
  • Macro AUC: +0.0260 / +0.0304 / +0.0243

The 23 held-out models never contribute outcomes to behavioral pretraining, so the gain is not tied to the identities of the 89 source models.

For RouterBench, exact-match and 5-gram MinHash near-duplicate overlap with EmbedLLM are both 0. On benchmark families absent from EmbedLLM, LogReg / MLP / KNN still gain +0.0111 / +0.0086 / +0.0144 AUC. We will make the pool definitions, query splits, K-sampling, and overlap protocol explicit in the revision.


W2 + Q2 — What does multi-model supervision add beyond difficulty?

Scalar difficulty explains most of the average gain, while per-model behavior adds model-specific information exactly where routing depends on model identity.

Under the same Qwen encoder, LoRA budget, and training schedule (IID-89, LogReg), macro AUC is:

  • Full Behavior: 0.7471
  • Difficulty: 0.7439
  • Task-label: 0.7359
  • Placebo: 0.7187
  • Raw: 0.7203

Difficulty recovers about 88% of the Raw→Full gain.

The residual Full−Difficulty gap is systematic. Full ranks higher in 15/18 protocol×router×seed cells (sign test p = 0.008). After aggregating seeds into six protocol×router cells, the mean gap is +0.0020 [0.0007, 0.0033], positive in 6/6 cells (p = 0.031). A Friedman test also ranks Full first (mean rank 1.17 vs. Difficulty 1.83, Best-ID 3.00, Raw 4.00; p < 0.001).

The gain concentrates where models disagree. In the two highest-disagreement bins, Full−Difficulty is +0.0044 / +0.0035 AUC. The highest-disagreement bin is positive in 3/3 seeds, with all confidence intervals above zero. By task, Full−Difficulty averages +0.0065 on knowledge-intensive tasks versus −0.0062 on reasoning-heavy tasks; the knowledge-minus-reasoning gap is positive in every seed: +0.023 / +0.011 / +0.004.

A direct geometry control gives the same conclusion. Difficulty-only neighborhoods achieve only 0.605–0.610 pair-preference agreement, below semantic neighborhoods (0.610–0.628) and far below behavioral neighborhoods (0.775–0.796). Scalar difficulty is predictive, but it cannot encode which models succeed and fail jointly.

Same-budget routing objectives are also weaker:

  • Full Behavior: 0.7468
  • RouteLLM-style: 0.7384
  • RouterDC-style: 0.7368
  • Raw: 0.7183

This shows that the gain comes from preserving per-model structure, not merely from using a routing-specific loss.


Q3 — Affordability rule and NQCA

The quality–cost trend remains positive under deployable pre-call affordability rules.

The frontier selects the highest-scoring model from the affordable set {m : C(q,m) <= B}. The submitted frontier used recorded realized API cost for C(q,m), which serves as a retrospective oracle reference.

We replace this with three pre-call rules:

  • pre_mean: training-set mean cost
  • pre_p90: training-set 90th-percentile cost
  • pre_len: mean cost scaled by query length

Affordability uses these estimates, while reported frontier quality and cost still use realized outcomes.

Across the three pre-call rules, 12/12 router×rule mean ΔNQCA values are positive. Thus, the direction persists without oracle affordability. We will report both oracle-reference and pre-call results.

NQCA is the normalized area under the quality–cost frontier over a common budget range. All operating points use the same router scores and affordability rule, with no test-quality-based point selection.


Q4 — Table 4 Average row

The correct values are Behavior = 0.7603 and mean paired ΔNQCA = +0.0021. The six per-router rows are unchanged, and all six mean ΔNQCA values remain positive. The revised Table 4 will be generated directly from the per-seed records.

Thanks for your response. However, I think the results do not yet show meaningful routing gains that transfer to unseen models. I maintain my score.

Reviewer_pYxDOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper argues that LLM routers rely on general-purpose query embeddings that are poorly suited to routing. As motivation, Section 3.2 shows that queries with similar correctness profiles across source models agree more on target-model preferences than semantically similar queries do (0.783 vs. 0.618). The proposed fix is to LoRA-tune Qwen3-Embedding-0.6B to predict which of 89 EmbedLLM models answer each query correctly, then drop the prediction head and use the frozen encoder in place of the original one. This swap improves eight existing routers on EmbedLLM (Table 2), helps more when few labeled queries are available (Table 3), and gives small gains on RouterBench (Table 4).

Critical strengths
  • The method is simple and works as a drop-in replacement, and each comparison holds the router and training protocol fixed.
  • The gains have the same sign across all eight routers, and they are larger in the low-data regime (e.g., +0.045 for LogReg at K = 1024).
  • The RouterBench experiment uses a disjoint model pool, which is a reasonable transfer test.
Critical weaknesses

1. The novelty is limited. Training the query encoder on query-model outcome data is already common in routing. RouteLLM fine-tunes a BERT classifier on preference data, Hybrid LLM fine-tunes a DeBERTa router, RouterDC trains the encoder contrastively from model performance, and EmbedLLM learns query embeddings from the same correctness matrix used here. The paper cites all of these, yet the framing suggests that routers usually keep the representation fixed. As a result, the contribution amounts to multi-label pretraining on a correctness matrix followed by frozen reuse, which is a standard recipe.

2. The gains are small and less consistent than claimed. Averaged over the eight routers in Table 2, routing reward improves by about 0.011 (roughly 1.7% relative). Moreover, the gains shrink for the strongest routers: LogReg, the best Raw router, gains only 0.0049, and the best Behavior router is only about 0.01 above it (0.6564 vs. 0.6466). On RouterBench, NQCA improves by 0.0025 on average, about 0.3% relative (Table 4). In addition, the abstract's "consistently improves" does not hold in Table 3, where Raw beats Behavior for MLP at K = 8 to 64, or in Figure 2, where Behavior loses over parts of the cost range. Since the main tables report no standard deviations despite three seeds, and since neither the best single model nor the oracle reward is given, I cannot tell how many of these differences are real or how much headroom they represent. For a method that needs correctness labels from 89 models on about 21K queries plus encoder fine-tuning, this is a weak return.

3. The most important baselines are missing. Every comparison pits a LoRA-tuned encoder against a frozen raw encoder with a light head on top, so some gain is expected. To support the claim that a reusable pretrained representation is the right design, the paper should compare against (a) the pretraining head used directly as a router, (b) end-to-end fine-tuning of the encoder with each router, and (c) RouterDC-style or EmbedLLM-style learned embeddings. Furthermore, only one base encoder is tested, so a stronger general-purpose embedding might close the gap without behavioral training.

4. All evaluation queries are in distribution. On EmbedLLM, queries are split at random, so test queries come from the same benchmarks and formats as the pretraining queries; only the models are held out. On RouterBench, the model pool is new, but the queries come from overlapping public benchmarks such as MMLU and GSM8K, and no overlap check is reported. This matters because the encoder is fine-tuned through a 64-d bottleneck on queries from a handful of benchmarks, and Figure 3(b) shows that benchmark category remains almost perfectly decodable. The encoder may therefore learn benchmark identity and do worse than the raw encoder on real traffic. A leave-one-benchmark-out evaluation and a deduplicated RouterBench split would test this.

5. It is unclear which models the routers choose from. Section 5.1 splits the models into 89 seen and 23 held-out, but Eq. 22 only says the router selects from "the model pool M." If the pool in Tables 2 and 3 includes the seen models, the encoder has already been trained on their outcomes, and Table 3 is not really a few-shot setting. This affects how every main result should be read.

Questions for authors
  1. Which models are in the routing pool for Tables 2 and 3: the 23 held-out ones, the 89 seen ones, or all 112?
  2. How does the pretraining head perform as a router, and how does end-to-end fine-tuning compare?
  3. What are the seed standard deviations for Tables 2 to 4, and what are the best-single-model and oracle rewards?
  4. How does Behavior compare with Raw when a whole source benchmark is held out, and on a RouterBench split deduplicated against EmbedLLM?
  5. How does a difficulty-only neighborhood perform in Section 3.2?
2 comments
AuthorsOpenReview ↗

Response to Reviewer pYxD

Response to Reviewer pYxD

Thank you for your review. We provide additional results and discussions in three directions: clearer positioning against query-adaptive routers, uncertainty/reference baselines in the main tables, and new controlled/OOD experiments.


W1: Our contribution is to disentangle query-representation learning from router design, not to introduce a new routing loss. RouteLLM/Hybrid LLM train complete routers; RouterDC jointly learns the query encoder, model embeddings, and contrastive objective. Their ablations do not extract the query encoder, freeze it, and evaluate it across unrelated routers. EmbedLLM is the closest representation work, but does not establish a reusable query encoder across router families. In our controlled test, frozen behavioral embeddings improve all eight router families in mean AUC (Table 2), while fine-tuning the encoder end-to-end for each downstream router changes accuracy by only Δ∈[-0.004,+0.003] . This isolates query adaptation itself as a substantial source of routing performance.


W2 + Q3: Macro AUC shows a clear representation gain; top-1 reward is less sensitive because binary correctness creates many outcome ties. Across 8 routers × 3 seeds, Behavior improves macro AUC in 24/24 comparisons. Query-level paired bootstrap gives LogReg +0.0257 [0.0192,0.0310] and KNN-128 +0.0288 [0.0235,0.0357]. Reward is weaker: only 5/8 routers are positive in all three seeds. However, Behavior and Raw have identical binary outcomes on 87.2% of queries; on the remaining 12.8%, Behavior wins 5,631 vs. 4,829 (p<0.001p<0.001), corresponding to +0.089 conditional reward. Thus AUC directly captures representation quality, while reward is resolution-limited by binary outcome ties. Revised Table 2 adds oracle 0.9697±0.0051, best fixed 0.5926±0.0120, random 0.4034±0.0054, Behavior+LogReg 0.6515±0.0115, and Raw+LogReg 0.6466±0.0120.

Regarding cost-performance trade-off, Encoder pretraining costs 0.93 GPU-h once; refitting a new pool costs 14–25 s CPU, while repeated end-to-end tuning adds another 0.93 GPU-h without accuracy gain.


W3 + Q2: All requested controls are now included. (i) The pretraining head alone gives 0.7446 AUC, versus 0.7471/0.7473 for frozen Behavior+LogReg/KNN. (ii) End-to-end downstream tuning gives Δ∈[-0.004,+0.003] relative to frozen reuse. (iii) With the same Qwen encoder, LoRA budget, and schedule, Full Behavior / RouteLLM-style / RouterDC-style / Raw obtain 0.7468 / 0.7384 / 0.7368 / 0.7183 AUC. (iv) A 4B Raw encoder improves over 0.6B Raw by +0.004–0.011 but remains 0.011–0.027 below 0.6B Behavior. These controls isolate representation supervision from router architecture and encoder scale.


W4 + Q4: The gain persists after removing overlap and under an unseen benchmark family. EmbedLLM↔RouterBench exact and 5-gram MinHash near-duplicate overlap are both 0. On RouterBench families absent from EmbedLLM, ΔAUC remains positive for LogReg/MLP/KNN: +0.0111/+0.0086/+0.0144. We also retrained the encoder after removing all MMLU queries and behaviors; on held-out MMLU, strict Behavior reaches 0.6072 AUC vs. 0.5818 Raw (+0.0254). These results rule out benchmark-identity memorization as the explanation for the ranking gain. Strict-holdout top-1 reward does not improve, so the claim is specifically cross-family representation/ranking transfer. We will include the overlap audit, cross-family RouterBench results, and strict leave-family-out experiment in the revised appendix.


W5+Q1: Tables 2–3 use the 89 seen models and unseen queries; Table 3 is a new-query low-supervision setting, not unseen-model adaptation. Behavioral pretraining uses qtrain×89q_{\rm train}\times89 seen-model outcomes. Table 2 evaluates unseen qtestq_{\rm test} queries on the same 89-model pool, while Table 3 varies only the number KK of labeled queries available to train the downstream router. We will rename this setting accordingly in the revision.

We additionally test frozen representation transfer to 23 held-out models and to all 112 models. For the 89 seen / 23 held / 112 all pools, Behavior−Raw is +0.0131/+0.0108/+0.0129 in reward and +0.0260/+0.0304/+0.0243 in macro AUC, respectively. The 23-model pool contains only models whose outcomes were never used during behavioral pretraining. The representation advantage therefore persists when the candidate pool is replaced by previously unseen models, rather than being specific to the identities of the 89 source models. We will include these held-model and full-pool transfer results in the revised appendix.


Q5: Difficulty alone does not explain the gap. With the same 56/56 split, at k=10k=10 Semantic / Difficulty / Behavioral agreement is 0.618 / 0.606 / 0.783. Behavioral exceeds Difficulty by +0.177, showing the gain comes from model-specific preference structure.

Thank you for the new experiments. The added controls, the clarified routing pool with results on the 23 held-out models, and the difficulty-only control resolve my concerns about baselines, the model pool, and Section 3.2.

However, my main concern remains: the routing-reward gains are small. Only 5 of 8 routers improve in all three seeds, and the LogReg gain (0.6515 vs. 0.6466) is below the seed standard deviation and about 1% of the gap to the oracle. The conditional-reward argument restates the same average gain of about 0.01. Moreover, top-1 reward does not improve in the strict-holdout setting, and the proposed supervision beats RouteLLM-style and RouterDC-style supervision by only about 0.01 AUC.

I therefore maintain my score.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.