Introspective Uncertainty Estimation for LLM-Based Code Generation

Thomas Klassert

cs.SESep 12, 2026

Introspective Uncertainty Estimation for LLM-Based Code Generation

Authors: Thomas Klassert

Organizations: Fachbereich Design Informatik Medien der Hochschule RheinMain

Abstract

Large Language Models (LLMs) are increasingly used for code generation but can produce fluent yet functionally incorrect outputs, which limits trust in their usage for practical software engineering workflows. This thesis investigates whether Introspective Uncertainty Estimation (IUE), based on internal hidden-state representations of LLMs, can reliably indicate correctness at the response and line levels for code generation tasks. The objective is to determine the extent to which hidden states encode information about functional code correctness and how this can be leveraged for practical risk assessment and fault localization. Methodologically, this thesis combines response-level evaluation on LiveCodeBench (LCB) and BigCodeBench (BCB) with an augmentation pipeline that derives token- and line-level labels from incorrect programs. In this setup, it compares static and dynamic response-level features, evaluates generalization across tasks, programming domains, and token positions, and studies line-level fault localization. The results show that hidden states contain a strong response-level correctness signal. Static single-token probes perform best, while more elaborate dynamic strategies yield no consistent gains. While generalization across tasks, domains, and token positions is feasible, setting-dependent degradation largely remains for real-world software projects. At a fine granularity, line-level prediction is substantially harder than response-level estimation. However, in a conditional localization setup with known-incorrect programs, Top-K point-of-failure ranking remains effective. Overall, the findings suggest that hidden states are a robust and informative resource for estimating functional code correctness, supporting a two-stage workflow that combines response-level risk screening with targeted line-level prioritization.

Figures & tables

Figure 2.1: A visualization of the transformer showing the residual stream for processing an input token and outputting a distribution over next tokens. [ 21 , Figure 8.1]

Figure 2.2: A block diagram of an LSTM cell. The cells are connected recurrently to each other, replacing the hidden units found in traditional recurrent networks. An input feature is computed using a standard artificial neuron. If the sigmoid input gate activates, its value can be accumulated into the state. The state unit has a linear self-loop whose weight is controlled by the forget gate. The cell’s output can be shut off by the output gate. All the gating units have a sigmoid non-linearity. The state unit can also serve as an additional input for the gating units. The black square indicates a delay of one time step. [ 15 , Figure 10.16]

Difficulty	Count	Percentage
Easy	322	30.5%
Medium	383	36.3%
Hard	350	33.2%

Table 4.1: Distribution of problem difficulties in the LiveCodeBench dataset.

Figure 4.1: Examples of tool usage in BigCodeBench (BCB). Each function call belongs to a domain-specific library. The distribution of each domain is computed based on the frequency of domain-specific libraries appearing per task. For example, “63%” in “Computation” means that there are 63% tasks in BCB using at least one computation library. [ 53 , Figure 4]

Figure 4.2: Response-level dataset generation pipeline: In Phase 1, benchmark prompts are used to generate candidate programs for each LLM, and correctness labels are assigned by executing benchmark test suites. In Phase 2, each saved prompt-response pair is replayed using prefilling with the same LLM to extract hidden-state features. Feature extraction can be executed in multiple runs to target various feature positions.

Model	Release Date	Knowledge Cutoff	Layers	Hidden Sizes
Qwen3-Coder [ 49 ]	Jul 31, 2025	Nov 20, 2024	48	2048
GPT-OSS-20B [ 33 ]	Aug 5, 2025	Jun 1, 2024	24	2880
NVIDIA-Nemotron-3-Nano [ 31 ]	Dec 15, 2025	Nov 25, 2025	52	2688
Olmo 3.1 Instruct (32B) [ 32 ]	Nov 20, 2025	Dec 1, 2024	64	5120

Table 4.2: Overview of the open-weight LLMs that were used for code generation to create the datasets.

Model	LCB	BCB Instruct	BCB Fusion
Qwen3-Coder	5561 / 3963 / 1026	5348 / 6052 / 0	6743 / 4650 / 7
GPT-OSS-20B	6488 / 1504 / 2558	5148 / 6195 / 57	6493 / 4847 / 60
NVIDIA-Nemotron-3-Nano	4641 / 663 / 5246	4949 / 6379 / 72	6217 / 5056 / 127
Olmo 3.1 Instruct (32B)	4551 / 3381 / 2618	4122 / 6732 / 546	5252 / 5869 / 279

Table 4.3: Response-level label statistics across dataset variants. Each cell reports correct / tests_failed / no_program counts.

Figure 4.3: 2D t-SNE distributions of select hidden-state features extracted from the last layer of Qwen3-Coder on LCB. The distributions differ between correct v.s. incorrect code generations and show varying degrees of separation across token positions.

Figure 4.4: Token- and line-level dataset augmentation pipeline: In Phase 1, incorrect programs are repaired by an auxiliary model and validated with benchmark test suites. In Phase 2, buggy and test-passing repaired programs are used to derive token- and line-level correctness labels. In Phase 3, augmented samples can be filtered based on rules stemming from the augmentation data.

Model	Kept (n, %)	Dropped by Filter (n, %)
		no_program	no_fix_found	line_filter
Qwen3-Coder	6329 (59.99%)	1134 (10.75%)	1928 (18.27%)	1159 (10.99%)
GPT-OSS-20B	6756 (64.04%)	2672 (25.33%)	893 (8.46%)	229 (2.17%)

Table 4.4: Filtering statistics for augmented LCB datasets. Kept (candidate was retained) / Dropped (candidate was filtered). Percentages are relative to all candidates (

n=10550

per model).

Var.	Tokens T/F (%F)	Lines T/F (%F)	Tok. $\mu$	Line $\mu$	Diff. E/M/H (%)
Qwen3-Coder
V1	756482/11431 (1.49%)	105056/1290 (1.21%)	121.3	16.8	49.3/39.1/11.6
V2	833748/137425 (14.15%)	116387/18194 (13.52%)	133.2	18.5	43.3/39.6/17.1
V3	182887/137425 (42.90%)	25575/18194 (41.57%)	185.0	25.3	11.0/46.9/42.1
GPT-OSS-20B
V1	971108/3386 (0.35%)	143270/393 (0.27%)	144.2	21.3	46.7/38.1/15.2

Table 4.5: Augmentation summary for Qwen3-Coder and GPT-OSS-20B (LCB). Variant definitions: V1 = small bugs, V2 = complete data, V3 = known bugs. (%F) denotes the percentage of incorrect (false) labels.

Probe Model	Last Code	Last Token	First Code	First Token
XGBoost	0.9026	0.9002	0.8804	0.8626
MLP (1 hidden layer)	0.8967	0.8945	0.8775	0.8619
MLP (2 hidden layers)	0.9057	0.8962	0.8827	0.8638

Table 5.1: Preliminary model comparison using single-token features. Results are AUROC(

\uparrow

) on the LCB dataset for Qwen3-Coder. The best result for each token position is in bold.

LLM	LCB (XGBoost / MLP-2)	BCB-Instruct (XGBoost / MLP-2)
Qwen3-Coder	0.9026 / 0.9057	0.6841 / 0.6947
GPT-OSS-20B	0.8610 / 0.8519	0.6374 / 0.6571
NVIDIA-Nemotron-3-Nano	0.8911 / 0.8841	0.6419 / 0.6381
Olmo 3.1 Instruct (32B)	0.8542 / 0.8556	0.7309 / 0.7407

Table 5.2: Two-layer MLP probe vs. XGBoost on the last code token feature of LCB and BCB-Instruct. Results are AUROC(

\uparrow

) with the better result for each cell in bold.

Dataset	Feature	Qwen3-Coder	GPT-OSS-20B	NVIDIA-Nemotron-3-Nano	Olmo 3.1 Instruct (32B)
LCB	LC	0.9026 / 0.8484 /0.4576	0.8610 /0.9238/0.3369	0.8911 / 0.9581 / 0.4415	0.8542 /0.8047/0.3287
	L	0.9002/0.8426/ 0.4814	0.8570/0.9213/0.3466	0.8621/0.9536/0.3766	0.8454/0.8015/ 0.3522
	FC	0.8804/0.8282/0.4318	0.8598/ 0.9287 / 0.3957	0.8292/0.9398/0.2869	0.8429/ 0.8091 /0.3478
	F	0.8626/0.8344/0.3445	0.7800/0.8912/0.1139	0.7981/0.9235/0.1192	0.8172/0.7918/0.2762
BCB-Instruct	LC	0.6841 / 0.5753 / 0.0957	0.6374/0.5541/-0.0280	0.6381/0.5168/ 0.0423	0.7309 / 0.5026 /0.0802
	L	0.6745/0.5293/0.0720	0.6532 / 0.5601 / 0.0596	0.6411 / 0.5294 /0.0326	0.7251/0.4804/ 0.1100

Table 5.3: Single-token XGBoost baselines across datasets and LLMs. Feature descriptions: L = Last token, LC = Last Code token, F = First token, FC = First Code token. Cells report AUROC(

\uparrow

)/F1(

\uparrow

)/BSS(

\uparrow

). Bold marks the best value per metric (AUROC, F1, BSS) within each model-dataset pair.

Dataset	Feature	Qwen3-Coder	GPT-OSS-20B	NVIDIA-Nemotron-3-Nano	Olmo 3.1 Instruct (32B)
LCB	F+L	0.9034 / 0.8533 / 0.4860	0.8348/0.9115/0.2955	0.8993 /0.9522/0.3928	0.8559/0.8123/ 0.3275
LCB	FC+LC	0.9012/0.8435/0.4507	0.8672 / 0.9309 / 0.3972	0.8856/ 0.9562 / 0.4226	0.8586 / 0.8168 /0.3200
BCB-Instruct	F+L	0.6839 / 0.5808 / 0.0948	0.6569 /0.5638/ 0.0756	0.6335/0.5313/-0.0132	0.6893/0.3971/0.0714
BCB-Instruct	FC+LC	0.6768/0.5801/0.0787	0.6549/ 0.5699 /-0.0422	0.6406 / 0.5325 / 0.0345	0.7264 / 0.4868 / 0.0730
BCB-Fusion	F+L	0.6209/0.7184/0.0356	0.7076 / 0.7601 / 0.1247	0.6790 / 0.6792 / 0.0345	0.7284 / 0.6124 / 0.0810
BCB-Fusion	FC+LC	0.6680 / 0.7332 / 0.0848	0.7011/0.7440/0.1128	0.6512/0.6547/-0.0033	0.7137/0.5993/0.0602

Table 5.4: Multi-token XGBoost baselines across datasets and LLMs. Feature descriptions: F+L = First token + Last token, FC+LC = First Code token + Last Code token. Cells report AUROC(

\uparrow

)/F1(

\uparrow

)/BSS(

\uparrow

). Bold marks the best value per metric (AUROC, F1, BSS) within each model-dataset pair.

Dataset	LLM	XGBoost (best single-token)	LSTM (full sequence)	LSTM (newline filter)
LCB	Qwen3-Coder	0.9026	0.8897 (-0.0129)	0.8824 (-0.0202)
	GPT-OSS-20B	0.8610	0.8508 (-0.0102)	0.8504 (-0.0106)
	NVIDIA-Nemotron-3-Nano	0.8911	0.7851 (-0.1060)	0.7778 (-0.1133)
	Olmo 3.1 Instruct (32B)	0.8542	0.8135 (-0.0407)	0.8008 (-0.0534)
BCB-Instruct	Qwen3-Coder	0.6841	0.6523 (-0.0318)	0.6707 (-0.0134)
	GPT-OSS-20B	0.6532	0.6524 (-0.0008)	0.6585 (+0.0053)

Table 5.5: Comparison of sequential model variants against the best single-token XGBoost baseline. Cells report AUROC(

\uparrow

), and values in parentheses denote absolute AUROC change relative to the XGBoost baseline.

Model, Filter Setting	AUROC	$\Delta$ vs. XGBoost
XGBoost (best single-token baseline)	0.9026	0.0000
LSTM, default entropy filter ( $H\geq 0.20$ )	0.8665	-0.0361
LSTM, top-entropy ( $H\geq 0.66$ )	0.8770	-0.0256
LSTM, middle-entropy band ( $0.33\leq H\leq 0.66$ )	0.8779	-0.0247
LSTM, low-entropy ( $H\leq 0.33$ )	0.8960	-0.0066
LSTM, low-high entropy band ( $0.15\leq H\leq 0.33$ )	0.8775	-0.0251

Table 5.6: Entropy-filtered sequential model variants against the best single-token XGBoost baseline for Qwen3-Coder on LCB.

H

denotes normalized token entropy. Default entropy filter is based on [ 52 ] , who found

0.2

to be an effective threshold for identifying high-risk tokens.

Method	BSS ( $\uparrow$ )	Accuracy ( $\uparrow$ )
IUE probe (last-token XGBoost, ours)	0.5888	0.8534
IGLB [ 5 ]	0.4680	0.8239
LINR [ 5 ]	0.4631	0.8216
HB [ 5 ]	0.3832	0.7973
Platt [ 5 ]	0.3769	0.7985
LOGR [ 5 ]	0.3026	0.8269

Table 5.7: Calibration evaluation on CALIBRI (Qwen3-Coder, LCB). BSS(

\uparrow

) and Accuracy(

\uparrow

) are reported, with the best result for each metric in bold. IUE probe reports our last-token XGBoost baseline. All other methods are from [ 5 ] .

Train $\rightarrow$ Test	Qwen3-Coder	GPT-OSS-20B	NVIDIA-Nemotron-3-Nano	Olmo 3.1 Instruct (32B)
LCB $\rightarrow$ BCB-Instruct	0.6483 (LC, $\Delta=\mathbf{-0.0358}$ )	0.5970 (L, $\Delta=-0.0562$ )	0.5838 (F+L, $\Delta=-0.0573$ )	0.6149 (FC+LC, $\Delta=-0.1160$ )
LCB $\rightarrow$ BCB-Fusion	0.6509 (LC, $\Delta=\mathbf{+0.0060}$ )	0.6875 (L, $\Delta=-0.0370$ )	0.6236 (L, $\Delta=-0.0577$ )	0.6713 (L, $\Delta=-0.0424$ )
BCB-Instruct $\rightarrow$ LCB	0.8240 (LC, $\Delta=\mathbf{-0.0786}$ )	0.7342 (LC, $\Delta=-0.1268$ )	0.7771 (L, $\Delta=-0.1140$ )	0.7410 (LC, $\Delta=-0.1132$ )
BCB-Fusion $\rightarrow$ LCB	0.8164 (LC, $\Delta=-0.0862$ )	0.7415 (F+L, $\Delta=-0.1195$ )	0.8426 (L, $\Delta=-0.0485$ )	0.8149 (L, $\Delta=\mathbf{-0.0393}$ )

Table 5.8: Cross-benchmark transfer between LCB and both BCB variants. Cells report best AUROC(

\uparrow

), best feature, and absolute difference to the best in-distribution AUROC on the target benchmark. Best delta (

\Delta=\text{OOD}-\text{ID}

) per transfer direction is in bold.

Model	ID Best	System	Time	Cryptography
Qwen3-Coder	0.6841	0.6643 (LC, $\Delta=\mathbf{-0.0198}$ )	0.6402 (L, $\Delta=-0.0439$ )	0.6353 (L, $\Delta=-0.0488$ )
GPT-OSS-20B	0.6569	0.6502 (F+L, $\Delta=\mathbf{-0.0066}$ )	0.6105 (L, $\Delta=-0.0464$ )	0.6281 (L, $\Delta=-0.0288$ )
NVIDIA-Nemotron-3-Nano	0.6411	0.6568 (F+L, $\Delta=+0.0157$ )	0.6508 (LC, $\Delta=+0.0097$ )	0.6746 (FC+LC, $\Delta=\mathbf{+0.0335}$ )
Olmo 3.1 Instruct (32B)	0.7309	0.7107 (LC, $\Delta=-0.0202$ )	0.7570 (LC, $\Delta=\mathbf{+0.0261}$ )	0.7147 (L, $\Delta=-0.0162$ )

Table 5.9: Representative cross-domain generalization on BCB-Instruct. Cells report best AUROC(

\uparrow

) on the held-out domain, best feature, and absolute difference to each model’s best ID AUROC on BCB-Instruct. Best delta (

\Delta

) per model is in bold.

Model	Shortfall $\mu$ ( $\downarrow$ )	$\Delta=\text{OOD}-\text{ID}$ $\mu$ ( $\uparrow$ )
Qwen3-Coder	0.0217	-0.0153
GPT-OSS-20B	0.0219	-0.0200
NVIDIA-Nemotron-3-Nano	0.0012	+0.0218
Olmo 3.1 Instruct (32B)	0.0178	-0.0141

Table 5.10: Aggregate cross-domain generalization on BCB-Instruct. Shortfall

\mu

reports the mean shortfall across all seven held-out domains for each LLM, and

\Delta

\mu

reports the mean signed difference across all seven held-out domains for each LLM. Best value per metric is in bold.

Dataset	Model	Random Tail (RT) Fraction
Dataset	Model	0.001	0.05	0.25	0.5	0.75	0.95	1.0
LCB	Qwen3-Coder	0.9045	0.8515	0.8351	0.8363	0.8279	0.8326	0.8202
	GPT-OSS-20B	0.8551	0.7983	0.7426	0.7364	0.7261	0.7232	0.7212
	NVIDIA-Nemotron-3-Nano	0.8617	0.8128	0.7444	0.7393	0.7808	0.7667	0.7437
	Olmo 3.1 Instruct (32B)	0.8440	0.7974	0.7687	0.7563	0.7713	0.7587	0.7708
BCB-Instruct	Qwen3-Coder	0.6754	0.6302	0.5961	0.6037	0.6027	0.5677	0.5827

Table 5.11: “Random tail” (RT) cross-token-position generalization for each LLM across LCB and BCB-Instruct. Each cell reports AUROC(

\uparrow

). Larger RT fractions represent a more challenging generalization scenario.

Dataset	Baseline	Qwen3-Coder	GPT-OSS-20B
V1	Token $\rightarrow$ Line	0.7258 / 0.0390	0.7431 / 0.0533
V1	Line-level (last code token)	0.7291 / 0.0601	0.7318 / 0.0127
V2	Token $\rightarrow$ Line	0.7575 / 0.2308	0.7294 / 0.0862
V2	Line-level (last code token)	0.7639 / 0.2593	0.7210 / 0.0651

Table 5.12: Line-level XGBoost baselines on augmented dataset variants. Cells report AUROC(

\uparrow

) / F1(

\uparrow

). The token

\rightarrow

line baseline applies max-pooling over token-level predictions, while the line-level baseline uses the last code token of each line. Bold denotes the better approach per metric within each dataset-model pair.

Dataset	Qwen3-Coder	GPT-OSS-20B
V1	0.7273 / 0.0891 ( $\Delta=-0.0018/+0.0290$ )	0.7557 / 0.0010 ( $\Delta=+0.0239/-0.0117$ )
V2	0.7402 / 0.2778 ( $\Delta=-0.0237/+0.0185$ )	0.7268 / 0.2015 ( $\Delta=+0.0058/+0.1364$ )

Table 5.13: Sequential line-level LSTM baselines on augmented dataset variants. Cells report LSTM AUROC(

\uparrow

) / F1(

\uparrow

) with metric-wise deltas in parentheses, where

\Delta_{M}=M_{\text{LSTM}}-M_{\text{XGBoost}}

and

M\in\{\text{AUROC},\text{F1}\}

(refer to Table 5.12 for XGBoost).

LLM, Line-level baseline (dataset)	Default F1 ( $t{=}0.5$ )	Best F1	Best Threshold ( $t$ )
Qwen3-Coder, XGBoost Token $\rightarrow$ Line (V1)	0.0390	0.0660	0.8
Qwen3-Coder, XGBoost Line-level (V2)	0.2593	0.3156	0.8
Qwen3-Coder, LSTM Line-level (V2)	0.2778	0.2886	0.7

Table 5.14: Post-hoc threshold optimization for select line-level baselines. Default F1 is reported at the standard

0.5

threshold, while Best F1 is the maximum F1 achieved across the tested thresholds

\text{t}\in\{0.1,0.2,\dots,0.9\}

. Best overall F1 is in bold.

Baseline	Qwen3-Coder	GPT-OSS-20B
XGBoost Token $\rightarrow$ Line	0.7267 / 0.6675	0.7015 / 0.3970
XGBoost Line-level (last code token)	0.7407 / 0.6560	0.7270 / 0.3905
LSTM Line-level	0.7410 / 0.6456	0.7294 / 0.4043

Table 5.15: Line-level fault localization evaluation on V3 (incorrect programs only) for each LLM. Cells report AUROC(

\uparrow

) / F1(

\uparrow

). F1 values are computed at each baseline’s best threshold from a sweep over

\text{t}\in\{0.1,0.2,\dots,0.9\}

. Best value per metric and LLM is in bold.

Baseline	Qwen3-Coder			GPT-OSS-20B
Baseline	Hit@1	Hit@2	Hit@3	Hit@1	Hit@2	Hit@3
Token $\rightarrow$ Line	0.6163	0.7209	0.8052	0.4937	0.6076	0.7089
Line-level (last code token)	0.5669	0.6483	0.7355	0.3418	0.5316	0.6203
Random (1000 trials)	0.3766 $\pm$ 0.0191	0.5102 $\pm$ 0.0182	0.5883 $\pm$ 0.0183	0.1940 $\pm$ 0.0376	0.3054 $\pm$ 0.0416	0.3836 $\pm$ 0.0439

Table 5.16: Top-

K

point-of-failure ranking evaluation on V3 (incorrect programs only) for each LLM. Cells report Top-

K

hit rate with

K\in\{1,2,3\}

(Hit@K,

\uparrow

) as defined in Subsection 4.4.4 . Random baseline reports mean

\pm

standard deviation over 1000 trials. Best value per metric and LLM is in bold.

Appendix figures & tables7 assets

Supplementary material from the paper’s appendix.

Appendix

Figure B.1: Combined 2D t-SNE distributions of select hidden-state features extracted from the last layer of the models on LCB. The distributions differ between correct v.s. incorrect code generations and show varying degrees of separation across the models and token positions.

Figure B.2: Combined visualization of three augmented programs generated by the minimal-edit fix prompt for LCB. Correct and incorrect insertion handling is visualized with green and red borders. In the program code, line labels are highlighted in light green and light red. A correctly flagged insertion is one where the nearest line after the insertion in the original code is flagged as incorrect. An incorrectly flagged insertion is one where the nearest line after the insertion in the original code is not flagged as incorrect.

Figure B.3: Combined visualization of domain label distributions for BCB across a) Instruct and b) Fusion prompt versions. The Fusion prompt increases the number of correct programs across all domains and models.

Model	ID Best	Computation
Qwen3-Coder	0.6841	0.6570 (L, $\Delta=-0.0271$ )
GPT-OSS-20B	0.6569	0.6213 (F+L, $\Delta=-0.0356$ )
NVIDIA-Nemotron-3-Nano	0.6411	0.6466 (L, $\Delta=+0.0054$ )
Olmo 3.1 Instruct (32B)	0.7309	0.7023 (L, $\Delta=-0.0286$ )

Appendix

Table C.1: Cross-domain generalization results on BCB-Instruct with Computation as held-out domain.

Model	ID Best	General
Qwen3-Coder	0.6841	0.6743 (L, $\Delta=-0.0098$ )
GPT-OSS-20B	0.6569	0.6402 (L, $\Delta=-0.0166$ )
NVIDIA-Nemotron-3-Nano	0.6411	0.6528 (L, $\Delta=+0.0117$ )
Olmo 3.1 Instruct (32B)	0.7309	0.7090 (LC, $\Delta=-0.0219$ )

Appendix

Table C.2: Cross-domain generalization results on BCB-Instruct with General as held-out domain.

Model	ID Best	Network
Qwen3-Coder	0.6841	0.7294 (F, $\Delta=+0.0453$ )
GPT-OSS-20B	0.6569	0.6701 (F, $\Delta=+0.0133$ )
NVIDIA-Nemotron-3-Nano	0.6411	0.7259 (F+L, $\Delta=+0.0848$ )
Olmo 3.1 Instruct (32B)	0.7309	0.7275 (L, $\Delta=-0.0034$ )

Appendix

Table C.3: Cross-domain generalization results on BCB-Instruct with Network as held-out domain.

Model	ID Best	Visualization
Qwen3-Coder	0.6841	0.6814 (FC+LC, $\Delta=-0.0027$ )
GPT-OSS-20B	0.6569	0.6379 (L, $\Delta=-0.0190$ )
NVIDIA-Nemotron-3-Nano	0.6411	0.6328 (LC, $\Delta=-0.0084$ )
Olmo 3.1 Instruct (32B)	0.7309	0.6967 (FC+LC, $\Delta=-0.0342$ )

Appendix

Table C.4: Cross-domain generalization results on BCB-Instruct with Visualization as held-out domain.

LLM Uncertainty Estimation

Large language model uncertainty estimation measures when outputs may be wrong, ambiguous, or unreliable to guide safer decisions.

See all 399 papers

Jun 8, 2026

Code Is More Than Text: Uncertainty Estimation for Code Generation

Large language models (LLMs) are increasingly deployed as code generators, where silently wrong programs pose real safety and reliability risks. Reliable uncertainty estimation (UE) is essential for selective prediction, human-in-the-loop review, and downstream agentic decisions. Yet most existing code UE methods are inherited from natural language (NL) generation and ignore properties that make code distinct. We argue that code differs from NL in three ways: a single wrong token can break an entire program (token fragility); algorithmic intent and concrete implementation can disagree independently (intent-code gap); and programs can be executed (executability). We instantiate these properties as three orthogonal uncertainty axes: lexical (Top-K token entropy), algorithmic (pseudo-code consistency), and functional (behavioral consistency). Across five code LLMs, our three-axis ensemble improves average AUROC from 0.696 for the strongest NL-derived baseline to 0.776 (+8.1 points). Notably, on Qwen3-14B, our single-pass Top-K token entropy matches the strongest multi-pass baseline while being over 3x cheaper; across models, it remains a competitive low-cost signal. These results suggest that code UE deserves code-specific design rather than direct NL ports.

Yuling Shi, Caiqi Zhang, Yuexian Li +4

Shanghai Jiao Tong University · University of Cambridge

Confidence Estimation in Language Models LLM Reliability LLM Uncertainty Estimation Code Language Models LLM Code Generation

Ask PDF

May 27, 2026

Functional Entropy: Predicting Functional Correctness in LLM-Generated Code with Uncertainty Quantification

Large language models have shown impressive capabilities in code generation, yet they often produce functionally incorrect code. Uncertainty quantification (UQ) methods have emerged as a promising approach for detecting hallucinations in natural language generation, but their effectiveness for code generation tasks remains underexplored. We systematically evaluate how UQ techniques transfer to code generation across three programming languages, five LLMs, and over 1,700 problems. We find that some token-probability-based methods generalize effectively without modification, while sampling-based methods relying on natural language inference (NLI) fail because NLI models cannot distinguish functionally different code, causing most responses to collapse into a single semantic cluster. To address this, we introduce functional equivalence methods, a family of code-specific methods that replace NLI-based semantic equivalence with an LLM-based functional equivalence assessment, including functional entropy, a code-specific analog of semantic entropy. Functional equivalence methods achieve top AUROC in 11 out of 15 model-benchmark combinations and the best calibration across most settings, consistently outperforming both NLI-based counterparts and all other methods evaluated.

Dylan Bouchard, Mohit Singh Chauhan, Zeya Ahmad +1

CVS Health®, Wellesley, MA, USA

Language Model Calibration LLM Uncertainty Estimation Automated Evaluation LLM Code Generation

Ask PDF

Jul 14, 2026

Code-MUE: Measuring Code LLMs' Uncertainty through Execution-based Semantic Interaction Graphs

As Code Large Language Models (LLMs) become central to modern software engineering, their inherent stochasticity poses significant real-world risks, where even minor errors can lead to severe functional, security, or safety consequences. Reliable automation, therefore, demands the ability to distinguish between confident, well-supported predictions and stochastic guessing. However, existing uncertainty estimation methods face a critical gap: white and grey-box techniques are often inapplicable to closed-source models, while standard "black-box" text metrics fail to capture the unique fragility of code, where syntactic variation does not always imply semantic divergence. To bridge this syntax-semantics gap, we introduce Code-MUE, a purely black-box framework that measures uncertainty through execution-based Semantic Interaction Graphs. Unlike prior approaches that rely on superficial textual similarity, Code-MUE grounds uncertainty in observable runtime behavior, calculating the Von Neumann entropy of the solution space to quantify global semantic diversity. A large-scale empirical study across eight state-of-the-art LLMs demonstrates that Code-MUE achieves a strong negative correlation with functional correctness (Spearman's correlation up to -0.98), significantly outperforming lexical and embedding-based baselines while enabling robust risk detection and selective prediction in practical workflows.

Xiaoning Ren, Yinxing Xue, Lei Ma +1

Xi’an Jiaotong University, China · Institute of AI for Industries, Chinese Academy of Sciences, China · The University of Tokyo, Japan +1

Uncertainty Quantification LLM Uncertainty Estimation Code Language Models

Ask PDF

Abstract

LLM Uncertainty Estimation

Explore similar work

Code Is More Than Text: Uncertainty Estimation for Code Generation

Functional Entropy: Predicting Functional Correctness in LLM-Generated Code with Uncertainty Quantification

Code-MUE: Measuring Code LLMs' Uncertainty through Execution-based Semantic Interaction Graphs