Paper deep dive
DART: Input-Difficulty-AwaRe Adaptive Threshold for Early-Exit DNNs
Parth Patne, Mahdi Taheri, Christian Herglotz, Maksim Jenihhin, Milos Krstic, Michael Hübner
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 7/21/2026, 3:35:37 AM
Summary
The paper introduces DART (Input-Difficulty-AwaRe Adaptive Threshold), a framework for early-exit deep neural networks that dynamically adjusts inference based on input difficulty. DART utilizes a lightweight difficulty estimation module, joint exit policy optimization via dynamic programming, and adaptive coefficient management. Experiments on CNNs (AlexNet, ResNet-18, VGG-16) and Vision Transformers (LeViT) demonstrate significant speedups, energy reductions, and improved efficiency scores compared to static networks and baselines like BranchyNet.
Entities (12)
Relation Signals (10)
DART → appliedto → CIFAR-10
confidence 95% · MNIST and CIFAR-10 were used as two standard datasets for evaluation.
DART → appliedto → MNIST
confidence 95% · MNIST and CIFAR-10 were used as two standard datasets for evaluation.
DART → evaluatedon → AlexNet
confidence 95% · Experiments on diverse DNN benchmarks (AlexNet...)
DART → evaluatedon → ResNet-18
confidence 95% · Experiments on diverse DNN benchmarks (...ResNet-18...)
DART → evaluatedon → VGG-16
confidence 95% · Experiments on diverse DNN benchmarks (...VGG-16)
DART → uses → Difficulty Estimation Module
confidence 95% · DART introduces three key innovations: (1) a lightweight difficulty estimation module
DART → uses → Dynamic Programming
confidence 95% · a joint exit policy optimization algorithm based on dynamic programming
DART → achieves → DAES
confidence 92% · under which DART achieves up to a 14.8 improvement over baselines
DART → comparedto →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Early-exit deep neural networks enable adaptive inference by terminating computation when sufficient confidence is achieved, reducing cost for edge AI accelerators in resource-constrained settings. Existing methods, however, rely on suboptimal exit policies, ignore input difficulty, and optimize thresholds independently. This paper introduces DART (Input-Difficulty-Aware Adaptive Threshold), a framework that overcomes these limitations. DART introduces three key innovations: (1) a lightweight difficulty estimation module that quantifies input complexity with minimal computational overhead, (2) a joint exit policy optimization algorithm based on dynamic programming, and (3) an adaptive coefficient management system. Experiments on diverse DNN benchmarks (AlexNet, ResNet-18, VGG-16) demonstrate that DART achieves up to \textbf{3.3$\times$} speedup, \textbf{5.1$\times$} lower energy, and up to \textbf{42\%} lower average power compared to static networks, while preserving competitive accuracy. Extending DART to Vision Transformers (LeViT) yields power (5.0$\times$) and execution-time (3.6$\times$) gains but also accuracy loss (up to 17 percent), underscoring the need for transformer-specific early-exit mechanisms. We further introduce the Difficulty-Aware Efficiency Score (DAES), a novel multi-objective metric, under which DART achieves up to a 14.8 improvement over baselines, highlighting superior accuracy, efficiency, and robustness trade-offs.
Tags
Links
- Source: https://arxiv.org/abs/2603.12269v1
- Canonical: https://arxiv.org/abs/2603.12269v1
Trouble viewing inline? Open PDF directly →
Full Text
32,855 characters extracted from source content.
Expand or collapse full text
DART: Input-Difficulty-AwaRe Adaptive Threshold for Early-Exit DNNs Parth Patne Brandenburg Technical University, Cottbus, Germany Mahdi Taheri Brandenburg Technical University, Cottbus, Germany Tallinn University of Technology, Tallinn, Estonia Christian Herglotz Brandenburg Technical University, Cottbus, Germany Maksim Jenihhin Tallinn University of Technology, Tallinn, Estonia Milos Krstic Leibniz Institute for High Performance Microelectronics, Frankfurt Oder, Germany Michael Hübner Brandenburg Technical University, Cottbus, Germany Abstract Early-exit deep neural networks enable adaptive inference by terminating computation when sufficient confidence is achieved, reducing cost for edge AI accelerators in resource-constrained settings. Existing methods, however, rely on suboptimal exit policies, ignore input difficulty, and optimize thresholds independently. This paper introduces DART (Input-Difficulty-Aware Adaptive Threshold), a framework that overcomes these limitations. DART introduces three key innovations: (1) a lightweight difficulty estimation module that quantifies input complexity with minimal computational overhead, (2) a joint exit policy optimization algorithm based on dynamic programming, and (3) an adaptive coefficient management system. Experiments on diverse DNN benchmarks (AlexNet, ResNet-18, VGG-16) demonstrate that DART achieves up to 3.3× speedup, 5.1× lower energy, and up to 42% lower average power compared to static networks, while preserving competitive accuracy. Extending DART to Vision Transformers (LeViT) yields power (5.0×) and execution-time (3.6×) gains but also accuracy loss (up to 17 percent), underscoring the need for transformer-specific early-exit mechanisms. We further introduce the Difficulty-Aware Efficiency Score (DAES), a novel multi-objective metric, under which DART achieves up to a 14.8× improvement over baselines, highlighting superior accuracy, efficiency, and robustness trade-offs. I Introduction Dynamic Deep Neural Networks (D2NNs) address the inefficiency of traditional static inference, where every input traverses the full network despite high energy consumption and latency, by adapting computation to input characteristics, making them more suitable for resource-constrained edge accelerators [7]. Early exit networks, introduced first by BranchyNet [13], integrate auxiliary classifiers at intermediate layers, allowing confident predictions to exit early. This approach demonstrated that many inputs require only shallow processing, enabling significant savings. However, reliance on fixed confidence thresholds and independent exit optimization limits adaptability during real-time execution. Subsequent work has improved exit policies. Zhou et al. [18] and Taheri et al. [12] employed reinforcement learning to optimize exits, while Xin et al. [17] introduced DeeBERT for transformer acceleration. RACENet [2] incorporates class-awareness through adaptive normalization but relies on computationally expensive MLPs at every layer, negating efficiency gains on constrained edge devices. Despite all efforts in the literature, three critical limitations persist. First, state-of-the-art approaches [14, 16] optimize exit thresholds independently, ignoring their interdependencies and yielding suboptimal routing policies. Second, the estimation of input complexity is computationally expensive [9, 6] or insufficiently representative of neural processing needs [8], limiting the real-time deployment. Third, current systems adopt static exit policies learned during training, leaving them vulnerable to distribution shifts and operational variability, with little work exploring online adaptation [5, 1] in different contexts that need to be studied in the D2N domain. To overcome these limitations, this paper introduces DART (Input-Difficulty-Aware Adaptive Threshold), a unified framework featuring: (1) Difficulty-aware input processing for lightweight real-time complexity estimation; (2) Joint exit threshold optimization using dynamic programming for globally coherent routing; and (3) Adaptive coefficient management with online learning–based updates for continuous refinement during deployment. The main contributions of this work are: • A unified framework (DART) that integrates difficulty-aware input processing, joint threshold optimization, and adaptive management to overcome fundamental early-exit limitations; • A practical and extensible deployment methodology that enables real-time execution on edge accelerators while ensuring portability across diverse neural network architectures; • Open-source release and comprehensive evaluation of the fully automated framework on state-of-the-art CNN and vision transformer benchmarks. The remainder of this paper is structured as follows: Section I presents the proposed methodology; Section I describes the experimental setup and results; Section IV concludes the paper. Figure 1: System-level architecture of the proposed Input-Difficulty-Aware early-exit DNN with DART integration. I Methodology Figure 1 illustrates the system-level integration of DART into an early-exit DNN, showing how difficulty estimation, adaptive thresholding, and coefficient management are realized within the model pipeline. DART implements a systematic approach to dynamic neural network optimization through three interconnected components that work synergistically to achieve optimal efficiency–accuracy trade-offs. Within a DART-enabled model, inputs are pre-processed by the lightweight difficulty-estimation module, exit thresholds are dynamically adjusted using the learned policies, and adaptation is performed online during inference. The framework itself provides the methodology and optimization algorithms that enable these runtime modules. I-A Difficulty-Aware Input Processing The foundation of DART lies in its ability to quantify input complexity through a lightweight preprocessing module. This module combines three complementary metrics to provide a comprehensive difficulty assessment. I-A1 Multi-Modal Difficulty Metrics Edge Density Computation: Edge density quantifies the structural complexity of input images through gradient analysis. The computation employs Sobel operators in both horizontal and vertical directions: Gx(x,y) G_x(x,y) =I(x,y)∗Sx, =I(x,y)*S_x, (1) Gy(x,y) G_y(x,y) =I(x,y)∗Sy, =I(x,y)*S_y, (2) G(x,y) G(x,y) =Gx2(x,y)+Gy2(x,y), = G_x^2(x,y)+G_y^2(x,y), (3) where I(x,y)I(x,y) represents the grayscale-converted input image of height H and width W, SxS_x and SyS_y are the Sobel kernels [11], and ∗* denotes convolution. The edge density score is computed as: αedge=1HW∑x=1H∑y=1W[G(x,y)>τedge], _edge= 1HW _x=1^H _y=1^W1 [G(x,y)> _edge ], (4) where [⋅]1[·] is the indicator function and τedge _edge is an adaptive threshold tuned per scene complexity [9]. Pixel Variance Analysis: Spatial variance captures texture complexity and local variations within the input. For an input tensor X∈ℝB×C×H×WX ^B× C× H× W (where B is batch size, C is channels, H is height, and W is width), the variance is computed across spatial dimensions: μb,c _b,c =1HW∑h=1H∑w=1WXb,c,h,w, = 1HW _h=1^H _w=1^WX_b,c,h,w, (5) αvariance _variance =1CHW∑c=1C∑h=1H∑w=1W(Xb,c,h,w−μb,c)2, = 1CHW _c=1^C _h=1^H _w=1^W (X_b,c,h,w- _b,c )^2, (6) following established texture complexity analyses. Gradient Complexity Assessment: Second-order spatial variations are captured using Laplacian operators to detect fine-grained patterns: αgradient=1HW∑x=1H∑y=1W|L(x,y)|,L(x,y)=I(x,y)∗Klaplacian, _gradient= 1HW _x=1^H _y=1^W L(x,y) , L(x,y)=I(x,y)*K_laplacian, (7) where KlaplacianK_laplacian is the Laplacian kernel, reflecting classic second-order edge detection. I-A2 Difficulty Score Fusion The final difficulty score combines all three metrics through a weighted fusion approach: α=w1⋅αedge+w2⋅αvariance+w3⋅αgradient,α=w_1· _edge+w_2· _variance+w_3· _gradient, (8) where α∈[0,1]α∈[0,1] is the final difficulty score, and the weights (w1,w2,w3)(w_1,\,w_2,\,w_3) are empirically determined via cross-validation using random search optimization [4]. I-A3 Difficulty-Aware Efficiency Score (DAES) To comprehensively evaluate the effectiveness of difficulty-aware routing, we introduce the Difficulty-Aware Efficiency Score (DAES), which combines accuracy, computational efficiency, and robustness to input complexity: DAES=Accuracy×Speedup×Power_Efficiency1+αDAES= Accuracy×Speedup×Power\_Efficiency1+α (9) Here, Power_Efficiency(m)Power\_Efficiency(m) is defined in Eq. 22, and α∈[0,1]α∈[0,1] is the difficulty score computed per input using Eq. 8. Difficulty_Score∈[0,1]Difficulty\_Score∈[0,1] is computed for each test input using our multi-modal difficulty estimation framework (Eq. 8). This ensures a fair complexity-aware evaluation across all methods, including static and non-difficulty-aware baselines, without introducing additional scaling factors. The DAES metric captures the fundamental trade-off in early-exit networks by jointly considering accuracy, efficiency, and robustness to input complexity. Higher DAES scores indicate models that achieve more balanced performance across heterogeneous input conditions, making the metric particularly relevant for real-world deployment. I-B Joint Exit Policy Optimization The core innovation of DART lies in its joint optimization approach that considers all exit points simultaneously, formulated as a global optimization problem to maximize overall efficiency and accuracy trade‐offs. I-B1 Problem Formulation Given a neural network with N exits, the optimization objective seeks threshold values =[τ1,τ2,…,τN−1] τ=[ _1, _2,…, _N-1] that maximize: ()=∑i=1Nπi()[Ai−βopt⋅Ci],J( τ)= _i=1^N _i( τ) [A_i- _opt· C_i ], (10) where πi() _i( τ) is the probability of exiting at layer i, AiA_i is the accuracy achieved when exiting at layer i, CiC_i is the computational cost incurred up to exit i, and βopt∈[0,1] _opt∈[0,1] is a trade-off parameter that balances accuracy preservation against computational efficiency gains, following dynamic programming principles [3]. I-B2 Dynamic Programming Solution We employ a value iteration algorithm over state representations s=(exit_index,αbin,confidencebin)s=(exit\_index, _bin,confidence_bin) to learn optimal exit policies. The Q‐value update combines immediate rewards and future expected returns: Q(s,a)=R(s,a)+γ∑s′∈P(s′|s,a)V(s′),Q(s,a)=R(s,a)+γ _s P(s |s,a)\,V(s ), (11) where R(s,a)R(s,a) balances accuracy and cost, γ is the discount factor, and transitions follow the MDP framework [15]. I-B3 Threshold Calibration We generate candidate thresholds using quantiles of the confidence distributions: τicandidate=quantile(i,q),q∈0.1,0.2,…,0.9, _i^candidate=quantile(C_i,q), q∈\0.1,0.2,…,0.9\, (12) where iC_i is the confidence distribution at exit i, following practices in early‐exit tuning [18]. I-C Adaptive Coefficient Management The adaptive management system continuously refines exit policies through multi‐scale strategies as follows. I-C1 Multi-Strategy Adaptation Framework Temporal Adaptive Strategy: Coefficients evolve based on recent performance via exponential decay: ct=αdecay⋅ct−1+(1−αdecay)⋅f(performancet),c_t= _decay· c_t-1+ (1- _decay )· f(performance_t), (13) where αdecay∈[0,1] _decay∈[0,1] is the decay factor, following online learning formulations [10]. Class-Aware Adaptation: Class‐specific coefficients update based on per‐class performance: cclass(t+1)=cclass(t)+η⋅(Atarget−Aclass(t)),c_class^(t+1)=c_class^(t)+η· (A_target-A_class^(t) ), (14) where AtargetA_target is the desired accuracy (e.g., 0.85), Aclass(t)A_class^(t) is the current accuracy for the specific class (e.g., ”car” or ”ship” in CIFAR-10), and η is the adaptation rate, inspired by meta‐learning updates [5]. During deployment, we use the model’s high-confidence predictions as pseudo-labels to update class statistics in the absence of ground truth. I-C2 Adaptive Selection and Tracking We maintain running statistics over a sliding window of the most recent w=1000w=1000 inferences (per exit and per class): accuracy, confidence distributions, and compute (time/energy). These statistics drive small periodic updates of the adaptive coefficients and thresholds. When multiple adaptation strategies (e.g., alternative coefficient sets) are available, we select the next strategy using the UCB1 rule to balance exploration and exploitation. UCB1 is a multi-armed bandit algorithm that intelligently chooses between trying new strategies and using proven successful ones, ensuring DART continuously learns optimal coefficient management, as formulated in the following equation: UCBi(t)=r¯i(t)+2lntni(t),UCB_i(t)= r_i(t)+ 2 tn_i(t), (15) where r¯i(t) r_i(t) is the windowed reward estimate (accuracy–cost trade-off from Eq. 10) and ni(t)n_i(t) counts selections of strategy i. If UCB selection is disabled, the system reduces to deterministic threshold adaptation driven by the same sliding-window statistics. I-D Framework Extensibility to Transformers To demonstrate the adaptability of our CNN-focused framework, we extended DART to vision transformers. For LeViT transformers, the framework adapts to token-based representations: ExitBlockViT(T)=MLP(LayerNorm(GlobalPool(T)))ExitBlock_ViT(T)=MLP(LayerNorm(GlobalPool(T))) (16) where T∈ℝB×N×DT ^B× N× D represents the token sequence with batch size B, N tokens, and D dimensions. Token-Level Difficulty Estimation: For transformers, we maintain the same difficulty estimation approach as CNNs, computing α from the input image before tokenization to ensure consistent difficulty assessment across architectures: αtoken=w1⋅αedge+w2⋅αvariance+w3⋅αgradient _token=w_1· _edge+w_2· _variance+w_3· _gradient (17) where the difficulty components are computed from the input image using Equations 4, 6, and 7 before tokenization, with weights (w1,w2,w3)(w_1,w_2,w_3). I-E Training and Inference Pipeline The training process integrates all components through unified optimization that simultaneously learns network parameters and exit policies. I-E1 Multi-Exit Loss Function The total loss combines contributions from all exits with progressive weighting: ℒtotal=∑i=1Nwi⋅ℒCE(y,y^i)+λ⋅ℒpolicyL_total= _i=1^Nw_i·L_CE(y, y_i)+λ·L_policy (18) where wi=iNw_i= iN emphasizes later exits. The term ℒCEL_CE represents the standard Cross-Entropy loss between the true labels y and the prediction y^i y_i from each exit. The term ℒpolicyL_policy is a regularization loss that encourages an efficient exit distribution by penalizing overuse of later exits. I-E2 Inference Optimization During inference, the framework applies the learned exit policy while adapting thresholds to the input difficulty. We increase the confidence requirement for difficult inputs to avoid premature early exits. Let α∈[0,1]α∈[0,1] denote the difficulty score of the current input (higher means harder), ∈[0,1]N−1 τ∈[0,1]^N-1 the learned base thresholds, and ∈ℝ+N−1 c _+^N-1 the learned per-exit coefficients. We first apply the coefficients element-wise, adapted=⊙, τ_adapted\;=\; c τ, and then form the difficulty-aware effective threshold at exit i as τi′=(τadapted)i+βdiff⋅α, _i \;=\;( _adapted)_i\;+\; _diff·α, (19) followed by clamping to [0,1][0,1]. Thus, easy inputs (α≈0α≈ 0) retain near-baseline thresholds, while hard inputs (α≈1α≈ 1) face higher thresholds and are more likely to continue to deeper exits. We tune the nonnegative sensitivity parameter βdiff≥0 _diff\!≥\!0 on a validation set to balance responsiveness and stability. Algorithm 1 DART Adaptive Exit Decision Algorithm 1: Input: Sample x, learned thresholds τ, coefficients c, difficulty scale βdiff≥0 _diff\!≥\!0 2: Compute difficulty score: α←fdifficulty(x)α← f_difficulty(x) 3: Apply adaptive coefficients: adapted←⊙ τ_adapted← c τ 4: for i=1i=1 to N−1N-1 do 5: Compute exit prediction: (y^i,confi)←Ei(hi)( y_i,conf_i)← E_i(h_i) 6: Difficulty-aware threshold (Eq. 19): τi′←(τadapted)i+βdiff⋅α _i ←( _adapted)_i+ _diff·α 7: Clamp to [0,1][0,1]: τi′←min(1,max(0,τi′)) _i ← \! (1, (0, _i ) ) 8: if confi>τi′conf_i> _i then 9: return y^i y_i, exit_index =i=i 10: end if 11: end for 12: return Final prediction from exit N This pipeline ensures that exit decisions incorporate both learned policies and real-time input characteristics, enabling adaptive inference that responds to input complexity variations. I Experimental Evaluation Experiments were conducted to evaluate DART across accuracy, computational efficiency, and adaptive behavior. All experiments were implemented in PyTorch with CUDA acceleration and executed on NVIDIA A100 GPUs. While experiments utilized A100 GPUs, the reported MACs and energy savings are architecture-agnostic metrics that directly translate to efficiency gains on edge accelerators. Three representative CNN architectures were selected as primary testbeds: AlexNet (8 layers, 61M parameters), ResNet-18 (18 layers, 11M parameters), and VGG-16 (16 layers, 138M parameters). MNIST and CIFAR-10 were used as two standard datasets for evaluation. To further examine framework generality, experiments were extended to LeViT-128s, a transformer-based model with 7.8M parameters, serving as a proof-of-concept for transformer applications. The difficulty estimation module used empirically determined weights of (w1=0.4,w2=0.3,w3=0.3)(w_1=0.4,w_2=0.3,w_3=0.3) for fusing edge density, pixel variance, and gradient complexity metrics. The difficulty-aware threshold adaptation used βdiff=0.3 _diff=0.3 as the sensitivity parameter. The adaptive coefficient manager employed an exponential decay strategy with αdecay=0.95 _decay=0.95. Performance was benchmarked against two baselines, including static models without early exits, and BranchyNet with fixed thresholds [13]. Evaluation metrics included top-1 accuracy, computational cost in multiply–accumulate (MAC) operations, wall-clock inference time, and energy consumption measured via NVIDIA-SMI. In addition, exit distributions were analyzed to assess routing patterns and adaptive behavior. I-1 Metric Definitions All latency, energy, and power measurements were obtained under identical conditions (same batch size, precision, dataloader, and warmup). Each method was executed R times, and the median latency was used to compute derived metrics. Speedup relative to static baselines was calculated as: Speedup(m)=TStaticTm,Speedup(m)= T_StaticT_m, (20) where TmT_m is the per-inference wall-clock time of method m. Average power was defined as: Pm=EmTm,P_m= E_mT_m, (21) with energy EmE_m obtained by integrating instantaneous power during inference. Finally, normalized power efficiency was reported as: Power_Efficiency(m)=EStaticEm,Power\_Efficiency(m)= E_StaticE_m, (22) with Power_Efficiency(Static)=1.0×Power\_Efficiency(Static)=1.0× by definition. I-A Performance Comparison Table I summarizes the results across all models and datasets. TABLE I: Performance and Difficulty-Aware Analysis (MNIST α=0.76α\!=\!0.76; CIFAR-10 α=0.85α\!=\!0.85). Architecture Method Acc.(%) Time(ms) Energy(mJ) Power(W) Speedup Power Eff. DAES MNIST Results AlexNet Static 98.97 0.09 5.90 65.56 1.0×1.0× 1.00 0.562 BranchyNet 99.13 0.08 5.27 65.88 1.13×1.13× 1.12 0.713 RL-Agent 99.49 0.06 2.29 38.20 1.50×1.50× 2.57 2.179 DART 99.31 0.03 1.15 38.33 3.0×3.0× 5.13 8.684 CIFAR-10 Results (CNNs) AlexNet Static 85.29 0.08 5.18 64.75 1.0×1.0× 1.00 0.461 BranchyNet 83.15 0.07 4.57 65.29 1.14×1.14× 1.13 0.579 RL-Agent 84.42 0.05 1.84 36.73 1.60×1.60× 2.82 1.888 DART 82.86 0.05 1.88 37.60 1.60×1.60× 2.76 1.978 ResNet-18 Static 88.32 0.27 17.66 65.41 1.0×1.0× 1.00 0.477 BranchyNet 87.72 0.16 10.43 65.19 1.69×1.69× 1.69 1.354 RL-Agent 87.87 0.14 8.10 57.84 1.93×1.93× 2.18 1.998 DART 85.35 0.12 7.53 62.75 2.25×2.25× 2.35 2.439 VGG-16 Static 79.16 0.20 9.41 47.05 1.0×1.0× 1.00 0.428 BranchyNet 81.82 0.11 3.70 46.25 1.82×1.82× 2.54 4.63 RL-Agent 80.89 0.10 3.91 39.13 2.00×2.00× 2.40 2.021 DART 80.20 0.06 2.54 42.33 3.33×3.33× 3.71 5.356 CIFAR-10 Results (LeViT Transformers) LeViT-128S Static 95.80 11.55 750.75 65.00 1.0×1.0× 1.00 0.518 DART 81.73 4.56 150.10 32.92 2.53×2.53× 5.00 5.588 LeViT-192 Static 96.91 19.94 1296.10 65.00 1.0×1.0× 1.00 0.524 DART 80.33 5.57 259.18 46.53 3.58×3.58× 5.00 7.772 LeViT-256 Static 97.28 62.55 4065.75 65.00 1.0×1.0× 1.00 0.526 DART 86.11 18.89 813.30 43.05 3.31×3.31× 5.00 7.704 DART consistently improves efficiency across CNNs. On CIFAR-10, it achieves a 1.60× speedup on AlexNet (82.86% vs 85.29% accuracy, 2.7× energy reduction), a 2.25× speedup on ResNet-18 (85.35% vs 88.32% accuracy, 2.3× energy reduction), and a 3.33× speedup on VGG-16 (80.20% vs 79.16% accuracy, 3.7× energy reduction). On MNIST, AlexNet with DART reaches 3.0× speedup and 5.1× energy reduction while slightly improving accuracy (99.31% vs 98.97%). 01122330.950.95111.051.05Training Iterations (×1000)Exit CoefficientCar (Easy)Ship (Hard)Cat (Medium) Figure 2: Evolution of adaptive coefficients during training for three CIFAR-10 classes based on real experimental data. For LeViT transformers, DART achieves 2.53–3.58× speedups but with accuracy reductions of up to 17 percentage points, indicating that CNN-oriented early-exit strategies are not directly transferable to attention-based models. I-B Difficulty-Aware Performance Observing CIFAR-10 inputs, it is evident that they exhibit moderate complexity with a mean difficulty score of α≈0.85α≈ 0.85, consistent across models, confirming that difficulty reflects dataset characteristics rather than architectural bias. Table I reports DAES values alongside standard performance metrics. Three insights emerge. First, CNNs benefit substantially: for example, VGG-16 improves from 0.428 (static) to 5.356 (DART), a 12.5× gain. Second, transformers also exhibit improvements: LeViT-128S improves from 0.518 to 5.588 (10.8×), LeViT-192 from 0.524 to 7.772 (14.8x), and LeViT-256 from 0.526 to 7.704 (14.6×), showing that DART’s principles generalize beyond CNNs. Third, across all architectures, DAES improvements confirm that DART exploits input complexity effectively to achieve favorable efficiency–accuracy trade-offs. TABLE I: Extensibility Study: LeViT Transformer Performance Analysis on CIFAR-10 Model Method Acc. (%) MACs (M) Time (ms) Speedup (×) LeViT-128S Static 95.80 282.1 11.55 1.00×1.00× DART 81.73 56.4 4.56 2.53×2.53× LeViT-192 Static 96.91 601.1 19.94 1.00×1.00× DART 80.33 120.2 5.57 3.58×3.58× LeViT-256 Static 97.28 1053.3 62.55 1.00×1.00× DART 86.11 210.7 18.89 3.31×3.31× To validate the efficiency of DART’s difficulty-estimation module against the state of the art, the computational overhead is compared against RACENet [2] using FLOPs and latency. Only the control mechanisms responsible for dynamic behavior are considered to ensure a fair overhead comparison, i.e., DART’s input-difficulty estimator and RACENet’s class-aware adaptive normalization. Latency values were measured on an NVIDIA GPU with a batch size of 128, averaged over 5,000 runs to capture per-sample throughput. DART’s DifficultyEstimator adds 78.9K FLOPs for lightweight input analysis, whereas RACENet’s adaptive normalization requires a dedicated MLP at every layer, contributing 716,912 additional parameters and 3.96M FLOPs. This results in RACENet incurring 50.3× higher compute overhead and a substantially larger memory footprint than DART, clearly highlighting its inefficiency for deployment under resource constraints I-C Adaptive Behavior Figure 2 illustrates the evolution of exit coefficients during training. The adaptive system learns class-specific strategies: for easy classes (car), coefficients decrease from 0.99 to 0.95, enabling more aggressive early exits. For hard classes (ship), coefficients increase from 0.98 to 1.05, resulting in more conservative exits. Medium classes (cat) show intermediate evolution (0.99 to 0.97). This demonstrates the framework’s ability to adapt policies dynamically based on real data distributions. I-D CNN Architecture Analysis A detailed analysis of CNNs highlights architecture-dependent benefits. AlexNet achieves the highest power savings (42%), while ResNet-18 and VGG-16 show distinct accuracy efficiency trade-offs, underscoring the importance of architecture-aware tuning. The results confirm that DART’s joint optimization converges to stable exit distributions, effectively balancing accuracy and efficiency across multiple exits while learning meaningful exit strategies. I-E ViT Architecture Analysis The extensibility study with LeViT models provides insight into applying DART to non-CNN architectures. While efficiency gains are consistent (2.5–3.6× speedups, substantial energy reduction), accuracy drops remain noticeable (up to 17 points). This limitation highlights fundamental differences between CNN and transformer representations: early transformer layers primarily capture token positioning and structural cues rather than semantic features, making early exits more detrimental than in CNNs. These results point to the need for transformer-specific early-exit mechanisms, such as attention-aware difficulty metrics, token-level exit strategies, and specialized calibration. Overall, the experimental results confirm that DART achieves consistent improvements across CNNs, with speedups of up to 3.33× and energy savings exceeding 5× while maintaining competitive accuracy. The framework adapts effectively to varying input complexities, learns class-dependent strategies in real time. The findings demonstrate the practicality of DART as a unified framework for dynamic neural network optimization on resource-constrained edge AI platforms. IV Conclusion This paper introduces DART (Input-Difficulty-Aware Adaptive Threshold), a framework that enhances early-exit neural networks by tackling suboptimal exit policies, missing input-difficulty awareness, and independent threshold optimization. DART integrates three innovations: (1) a lightweight difficulty estimation module with minimal overhead, (2) a joint exit policy optimization via dynamic programming, and (3) an adaptive coefficient management system. Experiments on AlexNet, ResNet-18, and VGG-16 show up to 3.3× speedup, 5.1× lower energy, and 42% lower average power versus static networks, with competitive accuracy. Extending DART to Vision Transformers (LeViT) yields power (5.0×) and execution-time (3.6×) gains but also accuracy loss (up to 17 percent), underscoring the need for transformer-specific early-exit mechanisms. Finally, the proposed Difficulty-Aware Efficiency Score (DAES) demonstrates up to 14.8× improvement over baselines, capturing DART’s superior accuracy–efficiency–robustness trade-offs. V Acknowledgements This work was supported in part by the Estonian Research Council grant PUT PRG1467 ”CRASHLESS“, EU Grant Project 101160182 “TAICHIP“, by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) – Project-ID ”458578717”, and by the Federal Ministry of Research, Technology and Space of Germany (BMFTR) for supporting Edge-Cloud AI for DIstributed Sensing and COmputing (AI-DISCO) project (Project-ID ”16ME1127”). References [1] J. T. Ash and R. P. Adams (2020-Dec.) On warm-starting neural network training. In Proc. 33rd Conf. Neural Information Processing Systems (NeurIPS), p. 3884–3894. Cited by: §I. [2] M. Ayyat, M. Osman, and T. Nadeem (2025) RACENet: real-time adaptive class-aware early-exit networks for edge devices. In 2025 IEEE International Conference on Pervasive Computing and Communications (PerCom), p. 152–158. Cited by: §I, §I-B. [3] R. Bellman (1957) Dynamic programming. Princeton University Press, Princeton, NJ. Cited by: §I-B1. [4] J. Bergstra and Y. Bengio (2012) Random search for hyper-parameter optimization. Journal of Machine Learning Research 13, p. 281–305. Cited by: §I-A2. [5] C. Finn, P. Abbeel, and S. Levine (2017-Aug.) Model-agnostic meta-learning for fast adaptation of deep networks. In Proc. 34th Int. Conf. Machine Learning (ICML), p. 1126–1135. Cited by: §I, §I-C1. [6] A. Forsythe, M. Mulhern, and M. Sawey (2008) Confounds in pictorial sets: the role of complexity and familiarity in basic-level picture processing. Behavior Research Methods 40 (1), p. 116–129. Cited by: §I. [7] Y. Han, G. Huang, S. Song, L. Yang, H. Wang, and Y. Wang (2022) Dynamic neural networks: a survey. IEEE Transactions on Pattern Analysis and Machine Intelligence 44 (11), p. 7436–7456. External Links: Document Cited by: §I. [8] Y. Lee, J. Lee, S. J. Hwang, E. Yang, and S. Choi (2020-12) Neural complexity measures. In Advances in Neural Information Processing Systems, NeurIPS, Vol. 34, p. 4372–4382. Cited by: §I. [9] E. Peli (1990) Contrast in complex images. Journal of the Optical Society of America A 7 (10), p. 2032–2040. Cited by: §I, §I-A1. [10] S. Shalev-Shwartz (2012) Online learning and online convex optimization. Foundations and Trends in Machine Learning 4 (2), p. 107–194. Cited by: §I-C1. [11] I. Sobel and G. Feldman (1968) A 3×3 isotropic gradient operator for image processing. Technical report Stanford Artificial Intelligence Project. Cited by: §I-A1. [12] M. Taheri, P. Patne, N. Cherezova, A. Mahani, C. Herglotz, and M. Jenihhin (2025) RL-agent-based early-exit dnn architecture search framework. In 2025 IEEE 28th International Symposium on Design and Diagnostics of Electronic Circuits and Systems (DDECS), p. 145–148. External Links: Document Cited by: §I. [13] S. Teerapittayanon, B. McDanel, and H. T. Kung (2016-Dec.) BranchyNet: fast inference via early exiting from deep neural networks. In Proc. 23rd Int. Conf. Pattern Recognition (ICPR), p. 2464–2469. External Links: Document Cited by: §I, §I. [14] J. Wang, B. Li, and G. L. Zhang (2024) Early-exit with class exclusion for efficient inference of neural networks. In Design, Automation & Test in Europe Conference (DATE), p. 1–6. Cited by: §I. [15] C. J. C. H. Watkins and P. Dayan (1992) Q-learning. Machine Learning 8 (3-4), p. 279–292. External Links: Document Cited by: §I-B2. [16] B. Wójcik et al. (2023) Zero time waste in pre-trained early exit neural networks. Neural Networks 168, p. 593–604. Cited by: §I. [17] J. Xin, R. Tang, J. Lee, Y. Yu, and J. Lin (2020-Jul.) DeeBERT: dynamic early exiting for accelerating bert inference. In Proc. 58th Annual Meeting Association Computational Linguistics, p. 2246–2251. External Links: Document Cited by: §I. [18] W. Zhou, X. Xiong, F. Ge, Z. Mao, and C. Wu (2020-Dec.) BERT loses patience: fast and robust inference with early exit. In Proc. 34th Conf. Neural Information Processing Systems (NeurIPS), p. 19330–19341. Cited by: §I, §I-B3.