UCS: Estimating Unseen Coverage for Improved In-Context Learning
Abstract: In-context learning (ICL) performance depends critically on which demonstrations are placed in the prompt, yet most existing selectors prioritize heuristic notions of relevance or diversity and provide limited insight into the coverage of a demonstration set. We propose Unseen Coverage Selection (UKS), a training-free, subset-level coverage prior motivated by the principle that a good demonstration set should expose the model to latent cluster unrevealed by the currently selected subset. UCS operationalizes this idea by (1) inducing discrete latent clusters from model-consistent embeddings and (2) estimating the number of unrevealed clusters within a candidate subset via a Smoothed Good--Turing estimator from its empirical frequency spectrum. Unlike previous selection methods, UCS is coverage-based and training-free, and can be seamlessly combined with both query-dependent and query-independent selection baselines via a simple regularized objective. Experiments on multiple intent-classification and reasoning benchmarks with frontier LLMs show that augmenting strong baselines with UCS consistently improves ICL accuracy by up to 2-6% under the same selection budget, while also yielding insights into task- and model-level latent cluster distributions. Code is available at https://github.com/Raina-Xin/UCS.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Explaining “UCS: Estimating Unseen Coverage for Improved In-Context Learning” (for a 14-year-old)
What is this paper about?
This paper is about helping LLMs do better “in-context learning.” In-context learning means you teach the model a new task by showing a few examples in the prompt (like giving 5–10 solved examples before asking it to solve a new one). The paper introduces a new way, called UCS (Unseen Coverage Selection), to choose which examples to put in the prompt so the model learns more effectively.
What questions are the researchers trying to answer?
The authors focus on four simple questions:
- How can we pick example sets that cover many different “types” of problems, not just similar ones?
- Can we estimate how much variety (or “unseen stuff”) we’re missing when we pick a set of examples?
- Can this be done without extra training or heavy computation?
- If we add this idea to existing selection methods, does the model actually perform better?
How does their method work? (Explained with analogies)
Think of your example pool as a big music library. Each song belongs to some hidden “vibes” or styles (not just genre labels). If you only play songs from one vibe, your friend won’t learn much about other styles. A good playlist (prompt) should cover many different vibes.
UCS does three main things:
- Turn each example into a “fingerprint” the model understands
- The paper uses the same model you’ll later ask to solve tasks to create a vector (a fingerprint) for each example.
- This keeps the “vibes” consistent with what the model actually “feels” is similar or different.
- Group examples by hidden “vibes” (latent clusters)
- Imagine each song is made from a mix of ingredients (like rhythm patterns, moods, themes).
- The method first learns a set of common “ingredients” and expresses each example as a mix of them.
- Then it groups examples with similar mixes into clusters. These clusters are the hidden “vibes” of the dataset.
- Estimate how much you haven’t covered yet (using a clever counting trick)
- Picture collecting stickers. If, in a pack of 10 stickers, you see many stickers you’ve only seen once, that suggests there are many more you haven’t discovered yet.
- UCS uses a classic statistical idea (the Smoothed Good–Turing estimator) that looks at how often clusters appear in your chosen set (like: how many clusters showed up once, twice, etc.) to guess how many clusters are still “unseen.”
- UCS then gives a score to a set of examples that rewards two things:
- covering many different clusters now, and
- likely revealing even more new clusters if you kept sampling.
Finally, UCS doesn’t replace existing pickers—it nudges them
- There are already methods that pick examples by similarity to the test question or by diversity.
- UCS adds a small bonus to their scoring that favors sets with broader coverage of clusters.
- This is “training-free” (no new training needed) and low overhead.
What did they find?
In plain terms: adding UCS on top of strong existing methods made results better across different tasks and models.
- Tasks: intent classification datasets (like figuring out what a user wants in a chat) and tough reasoning tasks.
- Models: several modern LLMs from different families and sizes.
- Improvements: typically 2–6% higher accuracy with the same number of examples in the prompt.
- Biggest boosts showed up when the original selection method was “global” (the same demos for all questions), where UCS cut down redundancy and increased variety.
- It also helped on challenging reasoning tasks, with some jumps over 8–12 percentage points in certain cases.
They also discovered something about the data:
- The hidden clusters follow a “long tail” pattern. A few clusters are very common, but many are rare.
- UCS naturally shifts example choices toward those rare clusters, avoiding repetition and making the prompt more informative.
Why is this important?
- Better prompts without extra training: You get more reliable performance just by choosing examples smarter.
- Works with what you already have: UCS plugs into popular selection methods and adds little computational cost.
- More fairness and coverage: By not over-focusing on common patterns, the model sees more of the rare but important cases.
- Insight into your data and model: The clustering view helps you understand what kinds of examples are common or rare for a specific task and model.
Any limitations or future ideas?
- The hidden clusters are found automatically, so they might not always match human labels perfectly.
- Most tests were on shorter texts and classification; future work should test long, complex reasoning or math.
- You need embeddings from the same model you’ll use, which adds a bit of preprocessing time.
- UCS was combined with classic selectors here; it could also be integrated with newer, learning-based selection strategies in the future.
In short: UCS is a smart “coverage-aware” helper that picks example sets so the model sees a wide range of hidden patterns. That leads to stronger, more consistent in-context learning—without extra training.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a concise list of concrete gaps and unresolved questions that future research could address:
- Statistical validity under adaptive (non-i.i.d.) selection: The Smoothed Good–Turing (SGT) unseen-species estimator assumes samples are drawn from the same process, but the subset here is adaptively selected via a base retriever plus a coverage prior. How biased is the unseen estimate under such adaptive selection, and can bias-correction or off-policy estimation be developed?
- Objective structure and optimization: The UCS coverage functional is subset-level and non-decomposable; there is no analysis of submodularity or approximate optimality guarantees when combined with greedy base selectors (e.g., DPP). Can one prove submodularity/submodular surrogates for Φ_UCS, or derive approximation bounds for UCS-regularized selection?
- Theory-to-performance linkage: The paper lacks a formal argument connecting higher estimated latent cluster coverage to improved expected task accuracy. Under what assumptions on model inductive bias, cluster quality, and task distributions does increasing Φ_UCS provably improve ICL performance?
- Estimator design choices: SGT weighting, truncation M, and damping parameters are set heuristically; only limited sensitivity is reported. Are there principled methods (e.g., cross-validated risk, Bayesian smoothing, or shrinkage) to select SGT hyperparameters that optimize downstream ICL performance?
- Expansion factor t selection: The extrapolation horizon t governs the strength of unseen coverage incentives; guidance is empirical and limited. Can t be tied to pool size, budget B, or cluster entropy in a theoretically grounded way, or tuned without labels using unsupervised criteria?
- Discretization fidelity: The coverage estimate depends entirely on discretization quality. What are the failure modes if DBSCAN parameters (eps, min_samples) or K (dictionary size) are mis-specified? Provide robustness bounds, automatic hyperparameter selection, or adaptive clustering algorithms that co-optimize for coverage utility.
- Noise handling and spectrum clamping: The method excludes DBSCAN “noise” clusters and clamps negative SGT outputs to zero, which may distort the frequency spectrum. What bias does this introduce, and can principled treatments of noise/outliers improve estimates?
- Cluster interpretability and validity: Evidence for semantic coherence is qualitative. Can cluster quality be audited systematically (e.g., with external annotations, purity/normalized mutual information vs. labels, or human evaluation), and does higher-quality clustering consistently yield larger UCS gains?
- Cross-task and cross-domain generality: Most experiments are short-input intent classification plus three small BBEH tasks (n≈40 eval). Does UCS hold on long-form generation, multi-hop QA, math/code reasoning (GSM8K, MATH, HumanEval), tool-use tasks, or structured outputs?
- Reasoning generality across models: BBEH experiments are only with Qwen2.5-7B. Are the UCS gains on reasoning robust across different LLM families and scales (e.g., Llama, Gemma, Mixtral) and with chain-of-thought or self-consistency prompting?
- Comparison to coverage-focused baselines: The paper cites coverage-based selection (e.g., Gupta et al., 2023) but does not compare directly. How does UCS perform against prior coverage methods and other unseen-species estimators (e.g., Chao estimators, jackknife/Poissonization variants)?
- Interaction with query-dependent selection: The UCS signal is subset-level; practical implementations for query-dependent selectors approximate it via incremental gains or spectrum-weighted heuristics. How closely do these approximations align with the ideal objective, and can efficient exact or tighter approximate algorithms be designed?
- Scaling to large pools and tight latency: Reported overheads are small on modest datasets, but the complexity of dictionary learning, clustering, and online UCS updates at web scale (millions of examples) is not assessed. What are the time/memory trade-offs and streaming/incremental variants?
- API-only and black-box settings: UCS assumes access to model-consistent hidden states for embeddings. Can UCS be adapted to black-box LLMs (API-only) using external encoders or prompt-based “proxy” embeddings without materially degrading performance?
- Label/content inclusion in embeddings: The current embeddings exclude labels to avoid leakage, but for tasks where output structure is crucial (program synthesis, theorem proving), might including outputs or rationales in the representation improve coverage relevance?
- Multi-task or mixed-pool settings: The method is not evaluated when the candidate pool contains heterogeneous tasks/instructions. Can UCS detect and manage multi-task cluster structures, preventing harmful cross-task “coverage” that reduces relevance?
- Rare-cluster quality risks: Prioritizing the heavy tail may surface outliers, mislabeled, or noisy examples. What safeguards (e.g., quality filters, robust clustering, uncertainty/consistency checks) are effective to prevent harmful rare-sample inclusion?
- Budget regimes and context limits: Sensitivity analyses cover small-to-moderate budgets; effects at large budgets (e.g., B≥32–64) and under strict context-length constraints remain unclear. How does UCS interact with truncation strategies and demonstration ordering?
- Coverage vs. relevance trade-off calibration: The λ regularization weight is tuned empirically. Can one develop adaptive or data-driven λ schedules that depend on per-query pool diversity or estimated cluster skew, without relying on labeled dev sets?
- Joint dictionary alignment: The joint-dictionary extension shows mixed results and potential degradation for stronger models. Are there better alignment strategies (e.g., Procrustes/CCA, contrastive objectives, manifold alignment) that preserve model-specific fine-grained semantics while enabling cross-model coverage priors?
- Language and domain transfer: All evaluations appear to be in English and specific domains (banking, multi-domain intents). How does UCS perform on multilingual datasets, low-resource languages, domain-shifted pools, or cross-lingual transfer?
- Effects on calibration and robustness: Beyond accuracy, does UCS improve or degrade confidence calibration, robustness to adversarial or OOD queries, or error consistency across runs?
- Prompt content interactions: The method focuses on selecting examples, not formatting or order. How does UCS interact with prompt ordering, separator templates, instruction phrasing, or rationale inclusion, and can coverage be defined over rationales/skills instead of inputs?
- Compatibility with policy-based/iterative selectors: Integration with RL or iterative selection (IDS, RETICL, RDES) is suggested but not realized. How can Φ_UCS serve as a reward/constraint in sequential decision-making pipelines, and what are stability/performance impacts?
- Reproducibility/statistical power: Some evaluations use small test sizes (e.g., 40 examples on BBEH) and three seeds. Larger-scale, statistically powered studies are needed to quantify effect sizes, variance, and significance across datasets and seeds.
- Safety, fairness, and bias: Prioritizing rare clusters may inadvertently amplify minority or sensitive content. How does UCS affect demographic fairness, harmful content exposure, and bias, and can constraints or fairness-aware coverage measures mitigate risks?
Practical Applications
Immediate Applications
Below is a set of concrete, deployable use cases that leverage UCS as a training-free, drop-in coverage prior to improve in-context learning (ICL) demonstration selection. Each item includes sectors, potential tools/workflows, and feasibility notes.
- Coverage-aware prompt builder for customer support and CX triage — software, enterprise
- What: Use UCS to select demonstration sets for intent classification in help-desk/chatbot routing and FAQ assistants, reducing over-representation of dominant intents and boosting accuracy on rare, long-tail intents.
- Tools/workflows: “PromptOps” plugin that adds
UCS-regularization to existing selectors (e.g., DPP, MDL, VoteK) in OpenICL- or LangChain-based pipelines; scheduled offline embedding + clustering; online scoring with λ tuning per task. - Dependencies/assumptions: Requires a labeled demo pool, access to model-consistent embeddings (ideally hidden states of the deployed LLM), and modest preprocessing (38–57s per dataset; ~0–3s online overhead). Gains shown are +2–6% under budget B=10.
- Long-tail incident and compliance classification for risk triage — finance, legal/compliance
- What: Improve few-shot prompts used in classifying alerts (e.g., AML flags, policy violations, regulatory categories) by prioritizing rare cluster coverage; reduces false negatives in tail categories.
- Tools/workflows: A “coverage dashboard” to visualize the cluster frequency spectrum and prompt composition; UCS-regularized selectors integrated into case triage services.
- Dependencies/assumptions: Labeled pool with representative tail cases; domain-specific validation and guardrails; UCS acts as a prior, not a standalone selector.
- Data auditing and coverage monitoring — industry ML-ops, academia
- What: Use the UCS clustering and spectrum to audit demonstration pools for heavy skew and redundancy; identify missing semantic regions and track coverage drift over time.
- Tools/workflows: “ICL Coverage Report” that logs seen/unseen cluster estimates, unique cluster counts, and heavy-tail exposure; integrates with data governance and dataset curation pipelines.
- Dependencies/assumptions: Access to embeddings from the inference model; UCS estimates are model-specific and sensitive to clustering hyperparameters.
- Active curation under annotation budgets — software, product analytics
- What: Prioritize new demos from underrepresented clusters for human labeling to maximize marginal coverage gains under fixed budgets; pair UCS with existing selection (MDL/DPP/VoteK).
- Tools/workflows: Human-in-the-loop curation queue sorted by UCS unseen-coverage gains; batch updates to dictionaries and DBSCAN clusters.
- Dependencies/assumptions: Requires periodic recomputation as the pool evolves; relies on Smoothed Good–Turing stability for frequency spectra.
- Better A/B prompt testing for ICL — software platforms
- What: Use UCS to create candidate prompt sets that explicitly vary coverage profiles; run fast A/B tests to measure tail-performance impact without retraining.
- Tools/workflows: Prompt experiment manager that tags each variant with
Φ_UCS(estimated total clusters) and unseen counts; quick rollouts based on observed tail improvements. - Dependencies/assumptions: Stable test distributions; consistent embedding model between prompt construction and serving.
- Education and tutoring assistants with broader topic exposure — education
- What: Improve few-shot examples for topic classification, concept tagging, and question categorization by emphasizing rare topics; yields better generalization across diverse subject matter.
- Tools/workflows: UCS-powered prompt templates for content tagging and lesson planning; cluster heatmaps for curricular coverage diagnostics.
- Dependencies/assumptions: Labeled demos per course/subject; short-input tasks benefit most (as evaluated in paper).
- Prototype triage for healthcare (non-clinical operations) — healthcare ops
- What: Use UCS to select demonstrations for administrative classification tasks (e.g., appointment routing, insurance category tagging, non-medical inbox triage) to reduce misses on rare categories.
- Tools/workflows: Coverage-aware prompt builder with guardrails; cluster distribution tracking to detect rare administrative scenarios.
- Dependencies/assumptions: Non-clinical use; domain validation required; avoid high-risk medical decision-making without extensive evaluation.
- Bug/issue triage and commit classification — software engineering/DevOps
- What: Improve few-shot classification of tickets and commit messages (component, severity, type) by covering less frequent modules and error types.
- Tools/workflows: UCS-regularized MDL/DPP for internal triage bots; dashboards showing cluster skew in repository- or product-specific pools.
- Dependencies/assumptions: Historical labeled triage data; periodic updates as codebases evolve.
- Edge-case test generation and QA — product QA, safety
- What: Sample rare clusters to assemble edge-case test suites; quantify how prompt selection impacts tail robustness prior to deployment.
- Tools/workflows: “Tail-focus” test harness using UCS cluster IDs; regression tracking keyed to tail distributions.
- Dependencies/assumptions: Sufficient tail coverage in pools; stable spectrum estimates across versions.
- RAG-plus-ICL pipelines with coverage-aware few-shot demonstrations — software
- What: In retrieval-augmented apps, add UCS to the demonstration selection path separate from retrieval to stabilize reasoning/formatting across diverse query types.
- Tools/workflows: Dual path: standard retrieval for content + UCS-regularized selector for few-shot formatting/decision examples; telemetry on tail performance.
- Dependencies/assumptions: Labeled demos for the decision/formatting component; consistent inference backbone for embeddings.
Long-Term Applications
The following use cases require additional research, scaling, or validation (e.g., longer contexts, structured outputs, multi-model alignment, safety/regulatory considerations).
- Coverage-aware selectors for long-form and structured tasks — software, education, healthcare
- What: Extend UCS beyond short-text intent classification to math/program synthesis, clinical narratives, and multi-step reasoning, adapting clustering and SGT to longer contexts and structured outputs.
- Tools/workflows: Hierarchical or multi-granular clustering; sequence-aware embeddings; task-specific coverage priors (e.g., skill/operation coverage).
- Dependencies/assumptions: New unit discovery methods (hybrid supervised/unsupervised); improved robustness for long sequences.
- Integration with reinforcement learning policies and iterative retrieval — robotics, software
- What: Use
Φ_UCSas a reward/regularizer in policy-based selection (RETICL, RL-based selectors) to balance instance relevance with latent coverage over selection rounds. - Tools/workflows: RL pipelines with UCS-derived reward terms; online spectrum updates; constrained optimization for latency.
- Dependencies/assumptions: Additional training; careful reward shaping to avoid coverage without relevance.
- What: Use
- Cross-model joint dictionaries for vendor-agnostic coverage metrics — industry, policy, academia
- What: Align embeddings across multiple LLMs to derive portable coverage scores that can be audited across vendors; define a “Coverage Score” standard for model cards.
- Tools/workflows: Joint dictionary learning and orthogonal alignment layers; evaluation suites that compare UCS-derived coverage across model families.
- Dependencies/assumptions: Paper shows mixed results (trade-offs for stronger models); needs more robust alignment methods; may dilute fine-grained semantics.
- Fairness, safety, and governance audits via latent coverage — policy, compliance
- What: Use UCS cluster distributions to detect over/under-exposure of subpopulations, rare categories, or edge-case semantics in deployment prompts; include coverage documentation in compliance reports.
- Tools/workflows: Governance dashboards showing tail coverage, shifts over time, and per-group exposure; audit trails for prompt updates.
- Dependencies/assumptions: Mapping clusters to human-interpretable categories remains non-trivial; may require domain labeling or semantic grounding.
- Real-time adaptive coverage balancing in streaming scenarios — finance, energy, IoT
- What: Dynamically adjust the demonstration set as query distributions shift (e.g., new fraud patterns, equipment anomalies), maintaining tail coverage with low-latency updates.
- Tools/workflows: Streaming UCS estimators; incremental clustering; lightweight coverage priors that update on-the-fly.
- Dependencies/assumptions: Efficient online clustering/estimation; latency constraints; continuous validation.
- Coverage-aware data acquisition and active learning — academia, industry ML-ops
- What: Drive data acquisition strategies by UCS-identified gaps, selecting samples for labeling from uncovered clusters to improve generalization and reduce data costs.
- Tools/workflows: Active learning queues prioritized by UCS unseen estimates; periodic re-clustering; budget-aware selection policies.
- Dependencies/assumptions: Stable latent units; labeling resources; monitoring of diminishing returns.
- Sector-specific reliability programs — healthcare (clinical), energy/manufacturing (asset reliability), finance (rare event detection)
- What: Incorporate UCS into reliability programs to ensure rare failure modes or clinical edge cases are represented in prompts; use standardized coverage metrics during certification.
- Tools/workflows: Safety case documentation with UCS coverage metrics; tail stress tests; cross-site evaluations.
- Dependencies/assumptions: High-stakes domains require extensive validation, domain-grounded clustering, and regulatory approval; UCS currently validated mostly on short, classification-style tasks.
- Education and assessment standards for prompt design — education policy, EdTech
- What: Establish best-practice guidelines and tooling that require latent coverage checks for prompts used in grading, tutoring, or curriculum tagging to avoid topic skew.
- Tools/workflows: EdTech platforms with coverage meters; periodic audits of demo pools; teacher-facing cluster visualizations.
- Dependencies/assumptions: Human-aligned semantics for clusters; stakeholder training; integration with institutional policies.
Notes on Assumptions and Dependencies (cross-cutting)
- Model-consistency is key: UCS benefits from embeddings produced by the same LLM used at inference; proprietary models may restrict hidden-state access, necessitating approximations via compatible embedding models.
- Labeled demonstration pools are required; UCS is a prior on subset coverage and does not replace relevance or diversity signals.
- Clustering choices (dictionary learning + DBSCAN) and SGT hyperparameters influence estimates; however, the paper’s sensitivity studies show robustness across reasonable settings.
- Most gains are demonstrated on short-text classification and reasoning tasks with budgets around B=10; extensions to long contexts and structured outputs will require further work.
- UCS is training-free and adds minimal overhead, making it practical to adopt in current ICL workflows; it should be paired with existing selectors (e.g., DPP, MDL, VoteK) and tuned via λ.
Glossary
- attention mask: A binary vector indicating which tokens in a sequence are valid (non-padding) and should be included in computations like pooling. Example: "with an attention mask indicating non-padding tokens."
- Big-Bench Extra Hard (BBEH): A suite of challenging reasoning benchmarks derived from BIG-bench, used to test advanced capabilities of LLMs. Example: "three Big-Bench Extra Hard (BBEH) reasoning tasks"
- chain-of-thought: A prompting technique that elicits step-by-step intermediate reasoning from an LLM to improve problem solving. Example: "including chain-of-thought, zero-shot reasoning, self-consistency, and automatic CoT construction"
- coverage functional: A set-level objective that estimates total latent coverage (seen plus predicted unseen clusters) achieved by a selected subset. Example: "the UCS coverage functional"
- coverage prior: A regularization term that biases selection toward subsets covering more latent cluster diversity. Example: "a lightweight coverage prior that can be incorporated into existing selection objectives"
- DBSCAN: A density-based clustering algorithm that groups points by density and labels outliers as noise. Example: "We then apply DBSCAN"
- determinantal point processes (DPP): Probabilistic models that favor diverse subset selection by assigning higher probability to sets with larger determinants of a kernel matrix. Example: "diversity via determinantal point processes (DPP)"
- dictionary atoms: The basis vectors learned in dictionary learning; data points are represented as combinations of these atoms. Example: "structured code over dictionary atoms"
- dictionary learning: A representation learning technique that learns a set of basis vectors (atoms) to reconstruct data via linear combinations of codes. Example: "via dictionary learning and clustering"
- expansion factor: The ratio controlling how far to extrapolate unseen coverage estimates relative to the current sample size. Example: "we define the expansion factor "
- frequency-of-frequencies (spectrum): The histogram over counts of how many types (e.g., clusters) occur exactly s times in a subset. Example: "frequency-of-frequencies (or spectrum)"
- Good--Turing functional: A classical series-based formula that estimates the number of unseen types from observed frequency counts. Example: "The classical Good--Turing functional is"
- In-context learning (ICL): The ability of LLMs to perform tasks by conditioning on example demonstrations in the prompt, without updating model parameters. Example: "In-context learning (ICL) enables LLMs to perform new tasks"
- influence-based approaches: Methods that estimate the impact of individual training or demonstration examples on model predictions (often via influence functions). Example: "Influence-based approaches such as InfICL estimate the effect of individual training examples on predictions"
- Joint Dictionary Learning: An approach that aligns embeddings from multiple models into a shared representation by learning a common dictionary and model-specific orthogonal mappings. Example: "We extend UCS to a Joint Dictionary Learning framework."
- latent clusters: Discrete groups induced from embeddings that capture hidden (unlabeled) semantic or skill-based structure in the data. Example: "clustering demonstrations into latent clusters and using their frequency to measure coverage"
- masked mean pooling: A pooling operation that averages hidden states over non-padding tokens to obtain a fixed-length embedding. Example: "via masked mean pooling:"
- Minimum Description Length (MDL): An information-theoretic principle selecting the hypothesis or subset that yields the shortest total description of data plus model. Example: "information-theoretic criteria such as minimum description length (MDL)"
- model-consistent: Using the same model at evaluation to generate embeddings so that clusters reflect that model’s inductive biases. Example: "UCS is designed to be model-consistent"
- orthogonal constraints: Restrictions requiring transformation matrices to be orthonormal (their transpose equals their inverse). Example: "subject to orthogonal constraints:"
- orthogonal transformation matrices: Matrices with orthonormal columns used to align different embedding spaces without distorting lengths or angles. Example: "optimizing orthogonal transformation matrices for each model."
- query-dependent: A selection strategy that tailors the demonstration subset to each specific test input. Example: "Some selectors are query-dependent"
- query-independent: A selection strategy that chooses a single global subset used for all test inputs. Example: "while others are query-independent"
- ridge coding: Obtaining representation codes by solving a ridge-regularized least squares projection to control magnitude and avoid pathological sparsity. Example: "We adopt ridge coding to avoid pathological sparsity"
- self-consistency: A reasoning method that samples multiple rationales and aggregates answers to improve reliability. Example: "chain-of-thought, zero-shot reasoning, self-consistency, and automatic CoT construction"
- Smoothed Good--Turing estimator (SGT): A smoothed variant of the Good–Turing estimator that more robustly estimates the number of unseen types based on observed frequency spectra. Example: "applies the Smoothed Good--Turing estimator"
- unseen-species estimation: The statistical problem of estimating how many unobserved types exist given sampled data. Example: "classical unseen-species estimation"
- VoteK: A similarity-based demonstration selector that aggregates votes (e.g., nearest neighbors) to choose examples; used as a baseline in OpenICL. Example: "representative methods based on similarity (e.g., VoteK)"
- zero-shot reasoning: Prompting a model to solve tasks without any in-context examples, often relying on general reasoning capabilities. Example: "chain-of-thought, zero-shot reasoning, self-consistency, and automatic CoT construction"
Collections
Sign up for free to add this paper to one or more collections.