Why Large Language Models Fail at Tabular Prediction
Abstract: LLMs have become the default tool for a remarkable range of tasks, yet they have had conspicuously little success at one of the most common machine learning workloads: predictive analytics over tabular data. This gap is the founding premise of the fast-growing field of tabular foundation models, but the question of why generic LLMs fail has remained open. We study a frontier LLM in its purest inference regime - a single generation pass over a prompt containing the full training and test data, with no tools, no agentic scaffolding, and no fine-tuning - and systematically evaluate five hypotheses for the failure: (a) an inability to handle noisy or non-linearly-separable data; (b) the linearised CSV format obscuring column structure; (c) the tokenisation of numeric values; (d) the number of test points classified per query; and (e) the dimensionality of the input. Controlled experiments falsify (a)-(d). Dimensionality, in contrast, is decisive: sweeping random linear projections of thirty-one benchmark datasets, the LLM is the only method among nine whose accuracy decreases as dimensionality grows, while every classical baseline stays flat or improves. A behavioural comparison against 252 configured classical models finds that in two dimensions the LLM predicts like a local, distance-based method (up to 91.6% grid agreement), but in higher dimensions no classical model - even when augmented with tuned, dimension-dependent noise - reproduces its predictions. We do not claim to have identified the internal mechanism; our results show, more modestly, that the LLM's capability dissolves with dimension in a way no noise-corrupted classical learner mimics - which explains why LLMs, so capable elsewhere, keep losing to fifty-year-old baselines on tables, while leaving the mechanism of the prediction as an open question.
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
What this paper is about (overview)
This paper asks a simple question: Why do big AI chatbots (LLMs, or LLMs) that are great at writing and reasoning struggle with a very common task in data science—predicting labels from spreadsheets of numbers (called “tabular data”)? The authors test several popular explanations and find one main reason: as the number of columns in the table grows, the LLM’s ability to learn from examples in the prompt breaks down, even when the useful information stays the same.
The main questions the paper asks
- Can LLMs learn from examples in the prompt to classify simple tabular data?
- What factors make them fail or succeed?
- When they do work, what kind of “learner” do they act like?
How the researchers tested it (methods, in plain language)
The authors test an advanced LLM in “pure inference” mode:
- They paste the entire small training set and the test rows into a single prompt,
- Ask the model to output the labels for the test rows,
- Use no tricks: no tools, no special system prompt, no fine-tuning, and no multi-step plans.
They compare the LLM to classic machine-learning methods you’d find in a toolbox (like k-nearest neighbors, logistic regression, random forests, Gaussian processes).
They run two kinds of tests:
- Real and synthetic datasets
- Small, standard datasets (like iris, wine, heart disease), plus two “extreme” synthetic ones: an easy, perfectly linearly separable dataset, and a very twisty, non-linear one.
- They do careful checks to make sure the LLM isn’t just recalling (memorizing) famous datasets from its training on internet text.
- Simple 2D toy worlds
- Tiny made-up tasks in two dimensions (so they’re easy to visualize), like moons, circles, checkerboards. The model sees 60 labeled dots, then must label points on a grid.
They test five common ideas about why LLMs might fail:
- H1: Overlapping/noisy classes are the problem (not cleanly separable).
- H2: The “flat CSV” text format hides the column structure (the model “can’t read vertically”).
- H3: Numbers are tokenized awkwardly; too many decimals confuse the model.
- H4: Asking for many test predictions at once spreads the model’s “thinking” too thin.
- H5: Too many columns (high dimensionality) makes the model’s ability collapse.
They use controlled experiments to isolate each idea. For example:
- To test H2 (“can’t read columns”), they literally include the correct answer as one of the columns and see if the model can find and copy it, even among many distractor columns.
- To test H3 (number tokenization), they round numbers to fewer decimal places and see if the model gets better.
- To test H5 (dimensionality), they use random projections that mix columns in a way that keeps the same information while changing how many columns the model sees—like blending ingredients so the taste stays, but served in more cups.
They also compare the LLM’s predictions to 252 versions of classic models to see which one behaves most like the LLM.
What they found (results)
First, a key hygiene check: some famous datasets are memorized
- When they hide one entire class from the prompt (so a real learner should score near zero), the LLM still labels those hidden rows correctly on several classic datasets. This shows the LLM likely memorized those datasets from the internet. Those contaminated datasets are removed from the main analysis.
Now, the five ideas tested:
- H1 (class overlap/noise): Rejected. Making the classes cleanly separated helps everyone a bit, but the LLM still lags way behind even when separation is perfect.
- H2 (CSV format hides columns): Rejected. The LLM can find and copy the “answer column” even with up to 60 columns. So it can “read vertically.”
- H3 (too many decimals): Rejected. Rounding numbers doesn’t help.
- H4 (too many labels in one go): Rejected. Asking for fewer predictions per prompt doesn’t improve accuracy.
- H5 (too many columns): Supported. This is the big one. As the number of columns grows, the LLM’s accuracy reliably drops—even when the total information is preserved. Classic models stay flat or get better with more columns; the LLM is the only one that gets worse.
What the LLM “acts like” when it does work
- In 2D toy tasks (few columns), the LLM’s predictions look a lot like distance-based methods:
- It most closely matches a Gaussian process with a short length scale and also does similarly to very low-k nearest neighbors.
- Agreement with these models’ decision maps is around 91–92%.
- In higher dimensions (more columns), nothing in a library of 252 classic models reproduces the LLM’s prediction patterns well (best agreement only about 65%), even after adding tuned, dimension-dependent random noise. So its high-dimensional behavior is unlike standard learners, and not just a “good model plus randomness” story.
Reasoning text isn’t reliable
- When asked to explain itself, the LLM’s written rules often don’t match the actual predictions it makes. Sometimes both the explanation and the predictions are good, sometimes predictions are good but the explanation is wrong, and sometimes both are off. So its “thinking” text should not be taken as a faithful description of how it decided.
Why this matters
- It explains a long-standing puzzle: LLMs often lose to decades-old methods on spreadsheet-like prediction tasks. The main culprit is not noise, not formatting, not decimals, and not asking for too many outputs—it’s the number of columns. As tables get “wider,” the LLM’s in-context learning ability fades in a way classic models don’t show.
- It shows why special-purpose “tabular foundation models” do well here: they’re designed for this job, while general LLMs are not.
What this means going forward (implications)
- Don’t expect a general LLM, used “as is” with a prompt, to beat classic models on typical spreadsheets—especially when there are many columns.
- If you must use an LLM on tables, keep feature count small or use purpose-built tabular models instead. Feature engineering or dimensionality reduction might help, but classic ML remains a strong baseline.
- Always check for memorization when evaluating LLMs on famous datasets; otherwise, scores can look better than real capability.
- Be careful with the LLM’s written explanations of its predictions. They can sound convincing but often don’t match what the model actually did.
- Research-wise, we need models tailored to tabular data and better understanding of why high dimensionality breaks in-context learning for LLMs.
In short: LLMs can learn from examples in a prompt on very small, low-column tables and behave like simple distance-based learners. But as the number of columns grows, their ability falls apart in a way classic models don’t share. That’s the key reason they underperform on tabular prediction tasks.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a consolidated list of what remains missing, uncertain, or unexplored, phrased to be directly actionable for future studies.
Mechanism behind the dimensionality collapse
- Identify the internal mechanism causing accuracy to decay with ambient dimensionality despite information-preserving transforms. Concretely: analyze attention patterns, head specializations, and cross-token interaction strength across feature columns as d increases; probe whether cross-feature “binding” degrades with column count.
- Test whether the collapse is tied to positional encoding across columns (e.g., absolute vs rotary positions) by re-serializing features with controlled positional structures and inspecting representation drift layer-by-layer.
- Determine whether the model is implementing an implicit distance-based learner that suffers from concentration-of-measure effects in high dimensions. Concretely: measure how predicted labels vary with controlled manipulations of pairwise distances and margins while holding class structure fixed.
- Disentangle whether the failure is architectural (transformer attention) or pretraining-distributional (lack of exposure to columnar integration at scale). Suggested: fine-tune-only attention layers or restrict data to synthetic columnar corpora and test for recovery of high-d performance.
Generality across models, sizes, tokenizers, and decoding
- Replicate the dimensionality sweep (H5) across diverse LLM families and sizes (e.g., GPT-4/4o, Llama 3/3.1, Mixtral/Mistral, Qwen series) to assess whether the slope and “breakpoint” dimension are model-dependent.
- Test tokenizer effects on numeracy and column integration by comparing byte-level BPE vs unigram/SentencePiece vs numeracy-aware tokenizers under identical tasks and prompts.
- Quantify sensitivity to decoding settings (temperature, top-p, deterministic decoding) on both accuracy and prediction agreement, including variance across repeated runs.
Confounds between dimensionality and prompt/token budget
- Decouple ambient dimensionality from token length by holding total token budget fixed while varying d (e.g., reduce number of rows as d grows; use fixed-width numeric encodings) and, conversely, vary token budget at fixed d to test long-context degradation separate from dimensionality per se.
- Place training and test blocks at varying distances within the prompt (recency vs primacy) to separate long-context position effects from column-count effects.
Serialization and interface design
- Go beyond “needle-in-haystack” to test column-major and transposed layouts, JSON column arrays, fixed-width tables, and markdown/HTML tables; compare column- vs row-major ordering for the same task and token budget.
- Test invariance to column and row permutations; quantify any positional biases (e.g., columns near the prompt start/end disproportionately weighted).
- Remove or obfuscate column headers and units to eliminate semantic priors; compare against prompts with rich schema descriptions to assess reliance on prior knowledge.
- Evaluate robustness to real-world formatting issues (missing cells, thousands separators, irregular spacing, mixed decimal/grouping conventions).
Data transformations and feature scaling
- Probe whether per-feature standardization, whitening, rank/quantile normalization, or learned orthogonal transforms mitigate collapse, beyond decimal rounding. Keep information content fixed and measure if scale invariance improves integration across features.
- Compare random projections with orthonormal projections (e.g., random Householder products) and with redundant feature augmentations (duplicate/linear-combination columns) to test whether specific projection statistics, not just d, drive failure.
Task and data coverage limitations
- Extend beyond small, low-row-count classification to: regression, multilabel, extreme-multiclass, strongly imbalanced targets, and uncertainty estimation (calibration, selective prediction).
- Include categorical features (low- and high-cardinality), mixed-type columns, and realistic encodings (one-hot, target, embedding-like numeric proxies). Test whether high-cardinality categoricals (which inflate d) accelerate the collapse.
- Vary training-set size (n) at fixed d to establish sample-complexity curves and n–d phase diagrams. Test whether increased n can partially offset the high-d failure up to context limits.
Benchmark hygiene and contamination
- Construct and release a rigorously decontaminated tabular benchmark suite (including synthetic, procedurally generated datasets with held-out generators) and standardized memorization probes. Current contamination checks show only dataset-level flags; a broader contamination audit pipeline is missing.
- Measure how column-name semantics (e.g., “radius_mean”) interact with memorization or prior knowledge; provide obfuscated-name baselines by default.
Behavioral surrogate modeling gaps
- Expand the surrogate search space to include: SVMs with RBF/Laplacian kernels, metric-learning models, modern MLPs with strong regularization, prototype networks, decision sets/lists, and kNN with learned Mahalanobis metrics; reassess prediction-level agreement in high dimensions.
- Replace simple dimension-dependent majority-class noise with input-dependent stochasticity (e.g., flips correlated with model margin, distance to nearest neighbor, or local density) and structured confusions; fit per-dataset noise models to better approximate LLM error geometry.
- Quantify whether the LLM’s high-d mistakes cluster along particular feature directions or subspaces; use subspace-restricted surrogates (low-rank kernels) to test if LLM acts on a small effective subspace that degrades as d grows.
Prompt protocol and ordering effects
- Systematically vary training-row order (shuffled vs class-clustered vs curriculum by margin) and interleave test rows with training rows to probe whether the model relies on local contextual cues over global column integration.
- Test single-test-row-per-turn vs batch predictions (beyond 1×/2×/4× splits) including conversational multi-turn settings to see if iterative focus alleviates integration failures without external tools.
Explanations and faithfulness
- Move beyond qualitative trace inspection to quantify faithfulness: intervention-based tests (contrastive edits to the “stated rule”), causal scrubbing, and counterfactual explanations to see if predicted labels causally depend on the textual rules.
- Correlate explanation structures with prediction reliability; determine whether certain explanation templates predict higher fidelity or accuracy.
Theory and mechanistic probes
- Relate findings to ICL-as-learning-theory: test whether high-d least-squares or gradient-descent circuits hypothesized in prior work fail under realistic tokenization, limited depth, or noise; design synthetic tasks that isolate these circuits.
- Apply representation probing (linear/nonlinear probes, logit lens) to detect whether intermediate layers compute per-column normalization, distances, or kernel-like similarities in low-d but fail to preserve them in high-d.
External validity and mitigations
- Verify whether minimal scaffolds (still within “no external tools”)—such as asking the model to compute standardized features or to emit a tiny in-prompt classifier (e.g., a threshold or distance rule)—can partially restore high-d performance, separating representational vs reasoning bottlenecks.
- Evaluate whether brief in-context “practice rounds” on auxiliary synthetic sub-tasks (e.g., distance comparisons or feature rescaling) improve subsequent tabular predictions, indicating a trainability-of-procedure within a single session.
These items pinpoint where the current study leaves uncertainty and outline concrete experiments or analyses that can close those gaps.
Practical Applications
Immediate Applications
Below are specific, deployable applications that leverage the paper’s findings and experimental protocol.
- LLM tabular “read/copy” helpers for data wrangling
- Sector: software/ETL, BI, spreadsheets
- Use case: Use LLMs to reliably locate, match, and copy specific columns across CSVs and spreadsheets (the “needle-in-the-haystack” result shows LLMs can read vertically and pick a designated column among many, even at high d).
- Tools/products/workflows: Excel/Google Sheets add-ins; ETL steps that auto-detect target/ID columns; schema-alignment chatops in data pipelines.
- Assumptions/dependencies: Reliable serialization and column names; access controls for sensitive data; does not extend to predictive modeling with many features.
- Dimension-based routing policy for predictive analytics
- Sector: MLOps across healthcare, finance, energy, retail
- Use case: Gate model choice by feature dimensionality; for d above a threshold (e.g., >16–32 features), automatically route to tree ensembles, gradient boosting, or tabular foundation models (TFMs) rather than LLMs-in-context.
- Tools/products/workflows: “Model router” middleware in MLOps; AutoML policy rule (“no LLM inference for high-d tabular classification”).
- Assumptions/dependencies: Thresholds may vary by task; local validation still required.
- Procurement and vendor evaluation checklists
- Sector: public-sector and enterprise AI governance
- Use case: Require dimensionality sweeps, a memorization probe, and a pure-inference evaluation (no tools, no fine-tuning) as part of RFPs and due diligence for AI systems claiming tabular prediction capability.
- Tools/products/workflows: Standard evaluation harness with (i) memorization probe, (ii) random-projection dimensionality sweep, and (iii) normalized-scoring dashboards.
- Assumptions/dependencies: Access to evaluation splits and prompts; reproducible logging.
- Benchmark hygiene: dataset memorization probe
- Sector: academia and industry
- Use case: Use the paper’s “impossible labels” test to detect if an LLM has memorized a benchmark dataset before taking scores as evidence of in-context learning.
- Tools/products/workflows: Open-source scripts integrated into experiment templates and CI for ML papers.
- Assumptions/dependencies: Known datasets may appear in pretraining corpora; probe must run before headline reporting.
- Guardrails for BI and spreadsheets
- Sector: enterprise analytics, finance ops, marketing ops
- Use case: Enable LLM assistance for column operations, joins, and descriptive summaries; block or warn on high-dimensional predictive requests (e.g., >20 columns) and suggest classical/TFM alternatives.
- Tools/products/workflows: Admin policies, spreadsheet macros, and BI connectors with “prediction guard” toggles.
- Assumptions/dependencies: Column count and task-type detection in UI; routing targets available.
- Education and training modules
- Sector: education, corporate upskilling
- Use case: Short labs that replicate H1–H5 to teach where LLMs work/fail on tables; use the 2D suite to visualize decision boundaries and show LLM ≈ distance-based methods in 2D.
- Tools/products/workflows: Jupyter labs, classroom kits, and instructor slide decks with the provided probes.
- Assumptions/dependencies: Access to LLM APIs and baseline models.
- Lightweight 2D boundary visualizer for teaching and quick diagnosis
- Sector: academia, data science teams
- Use case: Visualize LLM vs. GP/kNN decision boundaries in 2D probes to quickly diagnose when an LLM is acting like a local distance-based learner.
- Tools/products/workflows: Web app or notebook with grid-based overlays and agreement heatmaps.
- Assumptions/dependencies: Applicable to low-dim pilot datasets or projections.
- Compliance and privacy risk flags from memorization behavior
- Sector: compliance, legal, regulated industries
- Use case: If the memorization probe recovers labels on public datasets, flag potential training-data leakage and assess regulatory exposure (e.g., GDPR memorization risk for sensitive data).
- Tools/products/workflows: Risk register entries; auditing workflows that include the probe’s outcomes.
- Assumptions/dependencies: Jurisdiction-specific privacy rules; reproducible evidence retention.
- AutoML integration: LLM as data-cleaning/summarization assistant, not predictor
- Sector: software/AutoML
- Use case: Use LLMs to generate cleaning code, feature descriptions, and schema docs; route actual prediction to tree ensembles/TFMs based on dimension.
- Tools/products/workflows: AutoML pipelines with a “LLM-for-EDA” stage and a dimension-aware model selector.
- Assumptions/dependencies: Clear separation of descriptive vs. predictive steps.
- Negative-result-driven guidance for teams
- Sector: all applied ML
- Use case: Codify “don’ts”: avoid untooled LLMs for medium/high-dim tabular prediction; don’t expect numeric rounding or smaller test batches to fix accuracy; separability alone will not rescue LLMs.
- Tools/products/workflows: Internal playbooks and code templates with defaults and warnings.
- Assumptions/dependencies: Team adoption and periodic review as LLMs evolve.
Long-Term Applications
These opportunities require additional research, scaling, or productization informed by the paper’s findings.
- Purpose-built tabular foundation models (TFMs) as first-class enterprise tools
- Sector: software platforms, healthcare, finance, manufacturing
- Use case: Productize TFMs (e.g., TabPFN-like) that excel on tabular prediction where LLMs fail; offer managed inference with cost/latency SLAs and compliance features.
- Tools/products/workflows: Hosted TFM APIs; on-prem inference; AutoML integration; model cards for tabular compliance.
- Assumptions/dependencies: Continued TFM accuracy/latency gains; domain-specific robustness and monitoring.
- Hybrid architectures: LLMs for schema/semantics + TFMs/ensembles for prediction
- Sector: enterprise data platforms
- Use case: LLMs handle schema inference, feature naming, data documentation, and user instruction parsing; TFMs or tree ensembles perform the predictions; combine with audited routing.
- Tools/products/workflows: Orchestrators that translate natural-language tasks into tabular modeling pipelines with transparent routing and explanations.
- Assumptions/dependencies: Stable APIs; governance for model selection; human-in-the-loop sign-off.
- New training regimes to mitigate dimensionality collapse
- Sector: foundation model R&D
- Use case: Architectures or pretraining curricula that incorporate tabular inductive biases, synthetic tabular tasks, or non-autoregressive heads to sustain performance as d grows.
- Tools/products/workflows: Pretraining datasets that cover tabular distributions; specialized tokenization for numbers; mixed-objective training.
- Assumptions/dependencies: Vendor willingness; compute and data budgets; demonstrable generalization beyond curated probes.
- Auditing standards that mandate dimensionality and memorization tests
- Sector: policy and standards bodies (e.g., NIST, ISO), public procurement
- Use case: Official guidance requiring (i) dimensionality sweeps, (ii) memorization probes, and (iii) pure-inference evaluations for systems marketed for tabular prediction.
- Tools/products/workflows: Standardized reporting templates and reproducibility artifacts submitted with tenders.
- Assumptions/dependencies: Consensus-building; alignment with AI Act/sectoral regs.
- Truthful explanation tooling tied to actual predictors
- Sector: explainable AI (XAI)
- Use case: Replace LLM free-form narratives with faithful, model-linked explanations (e.g., GP/kNN surrogates in 2D, tree-based path explanations in higher dimensions) and auto-detect when LLM explanations deviate from behavior.
- Tools/products/workflows: “Faithfulness checkers” that compare stated rules to decision maps; explanation governance dashboards.
- Assumptions/dependencies: Surrogate fidelity; user education; sector norms.
- Privacy-safe LLM training and leakage detection
- Sector: model vendors, compliance tech
- Use case: Techniques to reduce and detect memorization (e.g., DP, redaction, auditing harnesses using the paper’s probe) for datasets likely present in pretraining.
- Tools/products/workflows: Memorization audits as part of model release; red-team kits for tabular leakage.
- Assumptions/dependencies: Utility–privacy trade-offs; performance retention.
- Enterprise “model router” platforms with SLAs and cost/accuracy controls
- Sector: software/SaaS
- Use case: Systems that automatically test candidate models via random-projection sweeps and route workloads across LLMs, TFMs, and classical learners based on d, accuracy, latency, and cost.
- Tools/products/workflows: Continuous evaluation, model registries, and policy engines tied to deployment pipelines.
- Assumptions/dependencies: Up-to-date benchmark harness; model catalog maintenance.
- Sector-specific deployments guided by the paper’s constraints
- Healthcare: Use TFMs/ensembles for EHR risk prediction; LLMs for cohort description and notes-to-feature mapping; require dimensionality and memorization audits before clinical pilots.
- Finance: Credit scoring and fraud detection with tree ensembles/TFMs; LLMs for data lineage docs and analyst guidance; procurement checklists with the paper’s probes.
- Energy/Manufacturing: Predictive maintenance with ensembles/TFMs; LLMs for report generation and maintenance-log parsing; dimensionality routing in MLOps.
- Assumptions/dependencies: Domain validation, regulatory approval, and monitoring for drift/bias.
- Robust benchmarks and leaderboards with contamination guards
- Sector: academia, open-source
- Use case: Community leaderboards that disallow results without memorization probes and dimension sweeps; track LLM vs. TFM vs. classical under identical conditions.
- Tools/products/workflows: Evaluations-as-a-service with reproducible pipelines.
- Assumptions/dependencies: Community adoption; curation overhead.
- On-device, low-dimensional assistants for sensor or form-like inputs
- Sector: IoT, field ops, SMB tools
- Use case: Where inputs are inherently low-d (2–10 features), LLMs can support simple local decisions or triage, with clear guardrails and fallbacks to classical models.
- Tools/products/workflows: Edge runtimes; offline validation packs; UI warnings when d grows.
- Assumptions/dependencies: Verified low-dimensionality; careful accuracy monitoring; clear user disclosures.
Notes on Assumptions and Dependencies (cross-cutting)
- The findings apply to “pure inference” prompting (single-pass, no tools, no fine-tuning). Tool-augmented or fine-tuned systems may perform differently and need re-evaluation with the same probes.
- Dimensionality thresholds are indicative (degradation observed by ≈16–32 features in the paper’s tests) and should be calibrated per domain via the provided sweeps.
- Initial evidence generalizes beyond a single model (Qwen corroboration in 2D), but broad model coverage requires further testing.
- Random projections approximately preserve information; always validate on your data.
- LLM self-explanations can be unfaithful; prefer faithful, model-linked XAI for any consequential use.
Glossary
- AdaBoost: An ensemble learning method that combines many weak classifiers to form a strong classifier by iteratively reweighting errors. "AdaBoost, gradient boosting, and a Gaussian-process classifier"
- agentic loops: Multi-step autonomous planning/execution patterns wrapped around a model to improve task performance. "retrieval, tool use, agentic loops"
- agentic scaffolding: External orchestration or tooling that structures an LLM’s behavior beyond a single forward pass. "no agentic scaffolding"
- autoregressive transformer LLM: A transformer that generates each next token conditioned on previous tokens. "an instruction-tuned, autoregressive transformer LLM"
- decision boundary: The surface in feature space separating predicted classes. "decision boundaries are reproduced almost exactly"
- dimensionality: The number of feature columns (input variables) in the dataset. "Dimensionality, in contrast, is decisive"
- distance-based method: A classifier that predicts based on distances to training points (e.g., kNN, certain GPs). "predicts like a local, distance-based method"
- Gaussian process: A nonparametric Bayesian model defining a distribution over functions, often used for classification/regression with kernels. "Gaussian processes with short length scales"
- Gaussian-process classifier: A Gaussian process model applied to classification tasks, typically via a probabilistic link function. "a Gaussian-process classifier"
- gradient boosting: An ensemble technique that builds additive models by sequentially fitting learners to the residuals of prior ones. "AdaBoost, gradient boosting, and a Gaussian-process classifier"
- grid agreement: The proportion of matching predictions between two models evaluated over a discrete evaluation grid. "up to 91.6\% grid agreement"
- in-context learning: Learning or adapting behavior from examples provided in the prompt without parameter updates. "Are LLMs capable of in-context learning over simple, classical classification problems?"
- instruction-tuned: Fine-tuned to follow natural-language instructions and produce helpful, aligned outputs. "an instruction-tuned, autoregressive transformer LLM"
- k-nearest neighbours (kNN): A nonparametric method that classifies a point by the labels of its k closest training neighbors. "kNN with "
- label-noise model: A model component that injects stochastic label corruption (here, increasing with dimension) to explain prediction behavior. "tuned, dimension-dependent label-noise model improves agreement by at most 0.64 percentage points"
- length scale: A kernel hyperparameter controlling how quickly similarity decays with distance in Gaussian processes. "length-scale 1"
- linearised CSV format: A row-wise, serialized text representation of tables that may obscure columnar structure. "the linearised CSV format"
- logistic regression: A linear classifier modeling the log-odds of class membership; often used as a baseline. "logistic regression most steeply"
- Matérn kernel: A covariance function for Gaussian processes controlling smoothness via a ν parameter. "Matérn kernel (with length-scale 1, nu 1.5)"
- majority-class guessing: Predicting the most frequent class for all inputs as a degenerate baseline or failure mode. "sits at or below majority-class guessing"
- majority vote: Aggregating multiple predictions by selecting the class with the most votes. "LLM majority-vote grid prediction"
- mean-L1 distance: The average absolute difference metric, here used to compare accuracy-profile vectors. "using mean-L1 distances between held-out accuracy vectors"
- memorisation probe: An evaluation that detects whether a model has memorized dataset labels from pretraining rather than learning from the prompt. "We therefore run a memorisation probe."
- Multidimensional scaling (MDS): A technique that embeds items in a low-dimensional space to preserve pairwise distances. "3D MDS of model families' predictions."
- numeric tokenisation: The process of splitting numeric values into tokens, which can affect how models process numbers. "H3 (Numeric tokenisation)."
- per-query test load: The number of test instances the model must label in a single generation pass. "H4 (Per-query test load)."
- principal components analysis (PCA): A dimensionality-reduction method that projects data onto directions of maximal variance. "with PCA fit"
- pure inference mode: Single-pass prompting without tools, multi-turn interaction, or fine-tuning. "we probe it in what we call pure inference mode"
- random forest: An ensemble of decision trees trained on bootstrap samples and random feature subsets. "random forest, regularised logistic regression, AdaBoost, gradient boosting, and a Gaussian-process classifier"
- random projection: A dimensionality transformation using a random matrix that approximately preserves distances/information. "random projections approximately preserve the information available for classification"
- serialisation format: The specific textual encoding of structured data (e.g., CSV) fed to the model. "H2 (Serialisation format)."
- StandardScaler: A preprocessing step that standardizes features by removing the mean and scaling to unit variance. "Scale-sensitive models are wrapped in a StandardScaler"
- stratified cross-validation: Cross-validation that preserves class proportions in each fold. "Splits are 5-fold stratified cross-validation repeated over 5 seeds"
- tabular foundation models: Purpose-built models designed to perform in-context learning on tabular data. "tabular foundation models"
Collections
Sign up for free to add this paper to one or more collections.