deepconf-confidence-filtering

name	deepconf-confidence-filtering
title	DeepConf: Test-Time Confidence-Based Filtering for Efficient Reasoning
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2508.15260
keywords	["confidence-scoring","test-time-optimization","reasoning-efficiency","token-reduction","quality-filtering"]
description	Filter low-quality reasoning traces using model-internal confidence signals at test time, eliminating weak paths during generation to achieve 99.9% accuracy while reducing token generation by up to 84.7%.

DeepConf: Test-Time Confidence-Based Filtering

Core Concept

DeepConf improves language model reasoning through intelligent filtering of low-quality reasoning traces using internal confidence signals. Rather than generating all reasoning paths equally and selecting via majority voting, DeepConf dynamically eliminates weak paths during or after generation based on the model's own uncertainty estimates. This approach requires no additional training and achieves extreme efficiency—generating significantly fewer tokens while maintaining or improving accuracy.

Architecture Overview

• Internal Confidence Extraction: Access model's hidden representations to estimate output quality
• Dynamic Path Filtering: Eliminate weak reasoning traces during generation
• No Model Retraining: Pure inference-time optimization without fine-tuning
• Selective Token Reduction: Reduce unnecessary computation while preserving quality paths
• Quality Preservation: Maintain or improve overall accuracy through selective scaling

Implementation Steps

1. Extract Model Confidence Scores

Obtain internal confidence signals from model representations:

import torch
import torch.nn.functional as F
from typing import Tuple, List

class ConfidenceExtractor:
    def __init__(self, model: torch.nn.Module):
        self.model = model

    def extract_confidence(
        self,
        input_ids: torch.Tensor,  # (batch, seq_len)
        output_ids: torch.Tensor,  # (batch, seq_len)
        method: str = "entropy"
    ) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        Extract confidence scores using various methods.

        Returns:
        - confidence_scores: (batch, seq_len) scores in [0, 1]
        - entropy_values: (batch, seq_len) raw entropy for diagnostics
        """

        
         torch.no_grad():
            outputs = .model(input_ids, output_ids=output_ids, return_hidden_states=)
            logits = outputs.logits  

         method == :
            
            probs = F.softmax(logits, dim=-)
            entropy = -torch.(probs * torch.log(probs + ), dim=-)
            max_entropy = torch.log(torch.tensor(logits.shape[-], dtype=torch.float32))
            confidence =  - (entropy / max_entropy)

         method == :
            
            probs = F.softmax(logits, dim=-)
            confidence = torch.(probs, dim=-)[]

         method == :
            
            probs = F.softmax(logits, dim=-)
            top2_probs = torch.topk(probs, k=, dim=-)[]
            confidence = top2_probs[:, :, ] - top2_probs[:, :, ]

         method == :
            
            hidden_states = outputs.hidden_states[-]  
            state_norms = torch.norm(hidden_states, dim=-)
            normalized_norms = (state_norms - state_norms.()) / \
                             (state_norms.() - state_norms.() + )
            confidence = normalized_norms

        :
             ValueError()

        
        confidence = torch.clamp(confidence, , )

         confidence, entropy  method ==