Semantic Geometric Calibration in Randomized Neural Feature Space

1 Introduction

Neural network classifiers underpin critical applications in computer vision, natural language processing, medical diagnosis, and autonomous systems [Caruana and Niculescu- Mizil, 2006; Zhang and Haghani, 2015]. While modern architectures achieve remarkable accuracy, accuracy alone does not capture predictive reliability. A model's accuracy summarizes the probability of a correct prediction over a test set, but does not quantify the reliability of individual predictions.

Although modern classifiers expose native confidence estimates, these are often biased. Confidence calibration aligns reported confidence with empirical correctness, transforming raw scores into interpretable uncertainty estimates. Calibration methods are commonly divided into post-hoc approaches, which fit a transformation on top of a trained model [Kull et al., 2019; Guo et al., 2017; Gupta and Ramdas, 2021], and ad-hoc approaches, which modify the training algorithm to produce calibrated confidence estimations by construction [Thulasidasan et al., 2019; Hendrycks et al., 2019]. Post-hoc methods are attractive when pretrained models are reused, but they can only correct systematic bias rather than introduce new information. In contrast, ad-hoc methods can encode richer uncertainty signals but require retraining or confidence-aware fine-tuning, which is often impractical.

These limitations motivate approaches that preserve the base model while augmenting confidence estimation with an additional signal. A natural candidate is geometry. Neural networks implicitly project data into high-dimensional representation spaces and separate classes within them. Lowconfidence predictions tend to arise near decision boundaries, where inputs are close to samples of different labels, or for atypical inputs that are far from nearby training examples [Mandelbaum and Weinshall, 2017; Jiang et al., 2018; Papernot and McDaniel, 2018; Lee et al., 2018; Tomani et al., 2023; Xiong et al., 2023; Y¨uksekg¨on¨ul et al., 2023]. Since we focus on high-accuracy models, which necessarily induce meaningful class separation, geometric structure provides a promising signal for confidence estimation.

Existing representation-space geometric methods depend critically on layer selection: practitioners must identify which intermediate layers yield representations with sufficient class separation. For example, DAC [Tomani et al., 2023] and TULIP [Benkert et al., 2024] require architecture-specific configurations, with DAC using prescribed layer sets and TULIP using manually determined placement rules that lack guidance beyond ResNets. Optimal selection of layers varies across architectures, datasets, and even training runs.

In this work, we ask whether such careful layer selection is truly necessary. Specifically, we ask: Is careful layer selection actually required for effective geometric calibration?

1.1 Contributions

1. We introduce Random Geometric Calibration (RGC)[code], a post-hoc geometric calibration framework that consistently outperforms prior work, reducing calibration error by approximately 78% on average relative to uncalibrated predictions. Instead of performing layer selection, we instantiate RGC with layer-based randomized sampling (RGCL) and with coordinate-based randomized sampling (RGCC).
2. We show that RGCL and RGCC eliminate the need for explicit layer selection by replacing it with randomized sampling, achieving calibration performance comparable to carefully tuned layer-selection strategies.
3. In RGCL, representations from the sampled layers are efficiently aggregated using spatial pyramid pooling. We further introduce RGCC, a more computationally efficient variant that attains performance comparable to RGCL. The efficiency of RGCC stems from the fact that it requires no feature compression and instead directly samples a fixed number of coordinates in the feature space. We provide an equivalence analysis showing that RGCL and RGCC achieve statistically indistinguishable performance at the 95% confidence level in 9 out of 13 model-dataset combinations.
4. Our evaluation demonstrates an average calibration error reduction of approximately 12% compared to several recent geometric calibrators, and up to 19% on individual configurations. We additionally analyze the computational overheads and show that RGCC is considerably faster than RGCL, while both methods require a longer one-time preprocessing step than prior work. Despite this overhead, both methods achieve several hundred confidence estimates per second at inference time.

2 Background and RelatedWork

This section defines confidence calibration and situates RGC within prior work on post-hoc and geometric calibration.

2.1 Confidence Calibration

Consider a classifier f : X → ∆C-1 that outputs a probability vector over C classes. Let ˆ y denote the predicted class and let ˆ p be the associated confidence (e.g., the maximum predicted probability). The model is said to be perfectly calibrated if

In practice, calibration is assessed using binning-based estimates such as the Expected Calibration Error (ECE). We partition predictions into M bins {Bm}Mm=1 according to ˆ p. The ECE is defined as

where N is the total number of samples, acc(Bm) denotes the empirical accuracy in bin Bm, and conf(Bm) denotes the average predicted confidence in that bin.

2.2 Post Hoc Calibration

Logit-based methods. Temperature Scaling (TS) [Guo et al., 2017] fits a single scalar T on a validation set and rescales logits as z/T before applying softmax. TS can substantially reduce ECE on in-distribution data, but as a monotone transformation it cannot correct failures in the underlying ranking of confidence (e.g., confident mistakes that remain confident). More expressive alternatives such as isotonic regression [Zadrozny and Elkan, 2002] or Dirichlet calibration [Kull et al., 2019] fit richer mappings, but still rely exclusively on the model's logits or predicted probabilities. When these signals degrade under shift, purely logit-based calibration has no independent information to exploit.

Ensemble and Bayesian methods. Deep ensembles [Lakshminarayanan et al., 2017] and MC Dropout [Gal and Ghahramani, 2016] can produce strong uncertainty estimates by aggregating multiple predictors or stochastic forward passes. However, these approaches typically require multiple models, architectural modifications, or increased inference cost. Our focus is on single-model, post-hoc methods. RGC is complementary to ensemble-based approaches and can be applied on top of ensemble predictions.

1. Geometric and Representation-Space Methods Geometric confidence signals. Geometric approaches derive confidence from distances to training data or local neighborhoods [Mandelbaum and Weinshall, 2017; Jiang et al., 2018; Papernot and McDaniel, 2018]. A representative example is the separation score used in pixel-space methods [Chouraqui et al., 2022], which compares the distance from a test input to its nearest same-class neighbor versus its nearest different-class neighbor:

While effective in settings where pixel geometry aligns with semantic class structure, such measures are less robust for normalized inputs or modalities where pixel-level distances are poorly aligned with class identity.

Latent-space methods and layer selection. To bridge this semantic gap, recent methods compute geometric or density signals in internal representation spaces [Lee et al., 2018; Tomani et al., 2023; Benkert et al., 2024], typically requiring architecture-specific layer configurations (Section 1). Our RGC instead replaces layer selection with uniform sampling, reducing tuning and mitigating overfitting risks.

3 Randomized Geometric Calibration

This section introduces Randomized Geometric Calibration (RGC), a post-hoc framework that augments confidence estimation with a geometric signal computed in an aggregated representation space. The central departure from prior representation-space methods is that RGC removes layer selection as a tuned component. Instead of prescribing architecture-specific taps (e.g., DAC, TULIP) [Tomani et al., 2023; Benkert et al., 2024], RGC samples intermediate indices uniformly at random and uses the resulting representation to derive a separation-based confidence score.

Algorithm 1 Randomized Geometric Calibration (RGC)

Input: Classifier f, training set Dtr, validation set Dval, number of layers L, dimension d (RGCL) or K (RGCC)

Output: Calibrator parameters (L, feat-params, Sval, g)

Offline (fit)

• 1: Sample random indices
• 2: for x ∈ Dtr ∪Dval do
• 3: Compute normalized embedding z(x)
• 4: end for
• 5: Build an NN index over {z(xi) : (xi, yi) ∈ Dtr}.
• 6: for (xi, yi) ∈ Dval do
• 7: Compute separation score s(xi)
• 8: end for
• 9: Store sorted scores Sval and compute ranks ˜ s(xi) using Eq. 12
• 10: Fit isotonic regression g on (˜ s(xi), 1[ˆ y(xi) = yi]).

Online (predict)

• 11: Compute normalized embedding z(x)
• 12: Compute s(x) via NN queries
• 13: Normalize ˜ s(x) using ranks in Sval
• 14: return calibrated confidence ˆ p(x) = g(˜ s(x)).

Algorithm 1 summarizes RGC. Concretely, RGC consists of four steps:

1. Random Index Sampling (RIS): sample a fixed-size subset of representation components uniformly at random (e.g., intermediate layers or individual coordinates).
2. Feature Construction: map the sampled components to a compact normalized embedding z(x).
3. Geometric Scoring: compute a separation score s(x) from nearest-neighbor distances to training representations.
4. CalibrationMapping: map scores to calibrated probabilities via isotonic regression.

Unless stated otherwise, we use fixed hyperparameters L = 6 and d = K = 256 across all architectures and datasets.

The RGC framework defines a single randomized geometric calibration pipeline for which we study two instantiations of the sampling step. RGCL samples intermediate layers and aggregates them using multi-scale pooling and random projection, while RGCC samples activation coordinates to obtain a compact embedding with lower computational overhead. Both variants share the same geometric scoring and calibration mapping.

3.1 Random Index Sampling

Let f be a neural network with extractable intermediate representations indexed by Lall = {1, . . . , Ltotal}, obtained via the following architecture-agnostic discovery-and-filtering procedure. We enumerate every torch.nn.Module via model.named modules() and retain feature-bearing modules - convolutional, normalization, linear, and pooling layers, and named composite blocks (e.g., ResNet bottleneck blocks, DenseNet dense blocks, transformer encoder blocks) - while excluding non-feature operations (activations, dropout, identity, flatten). Throughout, we use the term layer to denote one such extractable representation point.

The RGC framework fixes a random index set once and reuses it for both calibration and inference. We consider two instantiations: RGCL samples layer indices, and RGCC samples coordinate indices.

Layer index sampling in RGCL. RGCL samples a subset L ⊂ Lall of size |L| = L uniformly at random:

The sampled set L is used to extract activations {ϕℓ(x)}ℓ∈L. By avoiding performance-based index selection, this procedure reduces validation-set adaptivity beyond the final calibration map and removes architecture-specific heuristics for selecting layers or blocks.

Coordinate index sampling in RGCC. Unlike RGCL, RGCC does not sample a subset of layers. Instead, it defines a global coordinate space over all extractable layer outputs {ϕℓ(x)}ℓ∈Lall and samples coordinates directly from this space.

For each layer ℓ ∈ Lall, let ϕℓ(x) ∈ RCℓ×Hℓ×Wℓ be its activation tensor and uℓ(x) = vec(ϕℓ(x)) ∈ RDℓ its vectorization, where Dℓ = CℓHℓWℓ. We define the global activation vector by concatenation:

Let [D] = {1, . . . ,D}. We then sample K coordinates uniformly without replacement:

In practice, we precompute the mapping from each global index i ∈ [D] to a tuple (ℓ, c, h,w) and group sampled indices by layer to form an efficient per-layer sampling plan. This is an implementation detail; conceptually, sampling is performed over the global coordinate space without any layer selection.

3.2 Feature Construction

Given a fixed random index set from Section 3.1, RGC maps each input x to a compact embedding z(x) on which distances are computed. Our two instantiations differ in how z(x) is constructed: RGCL aggregates information from sampled blocks using pooling and random projection, while RGCC forms a sparse embedding by sampling activation coordinates. For clarity, we write zL(x) for RGCL and zC(x) for RGCC, and use z(x) when the choice is immaterial.

RGCL: Layer-Based Construction

RGCL constructs an embedding that aggregates multi-scale spatial information from each sampled layer. For ℓ ∈ L, let ϕℓ(x) ∈ RCℓ×Hℓ×Wℓ denote the activation tensor.

To obtain fixed-length vectors across heterogeneous spatial resolutions, we apply Spatial Pyramid Pooling (SPP) [He et al., 2015] with pyramid levels 4×4, 2×2, and 1×1. SPP maxpools in each cell and concatenates pooled values, producing

This preserves coarse-to-fine spatial structure while yielding a consistent representation length per layer.

Directly concatenating {vℓ(x)}ℓ∈L can be prohibitively high dimensional. We therefore compress each pooled vector and aggregate without materializing the concatenation. For each ℓ ∈ L, we sample a projection matrix Pℓ ∈ Rd×dℓ with i.i.d. entries from N(0, 1/d) and define

This project-then-sum construction is equivalent to projecting the full concatenation with a block-diagonal random matrix, but is more memory efficient.

Because dℓ scales with Cℓ, deeper layers (which typically have larger channel counts) contribute more coordinates to the pooled representation and therefore more signal to the aggregate. Random projection approximately preserves relative geometry, inducing a natural bias toward semantically richer late-stage representations without explicit layer weighting.

Finally, we L2 normalize the aggregated vector:

Distances are therefore dominated by angular similarity rather than scale. We use d = 256 in all experiments.

RGCC: Coordinate-Based Construction

RGCC replaces pooling and dense projection with coordinate sampling, yielding a lightweight embedding with substantially lower feature extraction overhead. Uniform sampling over coordinates implicitly weights blocks in proportion to their activation volume CℓHℓWℓ, which can place more emphasis on earlier high-resolution layers. The resulting lowercomplexity feature space can also act as implicit regularization when calibration data are limited, a trade-off we observe empirically in Section 5.

3.3 Geometric Separation Score

Given a normalized embedding z(x), RGC computes a scalar score that reflects local geometric separation relative to the training set Dtr. Following Chouraqui et al. [Chouraqui et al., 2022], we compare the distance from a query point to its nearest same-class training representation versus its nearest different-class training representation, where class membership is defined with respect to the model's predicted class.

Let ˆ y(x) be the predicted class for x. Define

Let dfriend(x) = minz′∈Zfriend(x) ∥z(x)-z ′ ∥2 and dnon(x) = minz′∈Znon(x) ∥z(x) - z ′ ∥2. The separation score is

Positive values indicate that the nearest neighbor from the predicted class is closer than the nearest neighbor from other classes, corresponding to high geometric confidence. Negative values indicate proximity to competing classes and often correlate with ambiguity or error.

3.4 CalibrationMapping

Separation scores are not probabilities and can vary in scale across architectures and feature constructions. We convert scores into calibrated probabilities using rank-based normalization followed by isotonic regression.

The normalization maps scores to a uniform [0, 1] scale. We adopt rank-based normalization (empirical cumulative distribution function) rather than linear scaling. Linear methods such as percentile clipping can be sensitive to changes in the score distribution, since samples outside the calibration range may be mapped to boundary values, reducing the resolution of the geometric signal. Rank-based normalization mitigates this saturation by mapping scores to their relative rank, preserving ordinal information across the full range.

Let Sval = {s(xi) : (xi, yi) ∈ Dval} be the set of separation scores computed on the validation set, and let N = |Dval|. Define

We then fit a one-dimensional isotonic regressor g : [0, 1] → [0, 1] on Dval, minimizing squared error between g(˜ s(xi)) and the correctness indicator 1[ˆ y(xi) = yi] [Zadrozny and Elkan, 2002]. The final calibrated confidence is

4 Experimental Setup

Datasets. We evaluate on three standard datasets: CIFAR10 [Krizhevsky, 2009] (60K images, 10 classes), CIFAR100 [Krizhevsky, 2009] (60K images, 100 classes), and TinyImageNet [Le and Yang, 2015] (200 classes, 500 images per class at 64×64 resolution). For all datasets, we reserve 10% of the training data for calibration fitting, the remaining 90% serves as the training set for geometric methods.

Architectures and Training. We used the following well-known neural networks for evaluation: ResNet18/50/101/152 [He et al., 2016], DenseNet-121 [Huang et al., 2017], and DINOv2-Large [Oquab et al., 2024]. ResNet and DenseNet are trained from scratch with stochastic gradient descent (SGD). For ResNet models we follow the original training protocol [He et al., 2016], reducing learning rate when validation accuracy plateaus. For DenseNet we use a warmup-to-cosine schedule [Loshchilov and Hutter, 2017]. Following the standard evaluation protocol for selfsupervised models [Oquab et al., 2024], we use linear probing with inputs resized to 224×224, training only the classification head while keeping the backbone frozen. Our primary evaluation uses cross-entropy loss.

Implementation and Evaluation. We evaluated sensitivity to the main RGCL hyperparameters: the number of layers L and the embedding dimension d. Across 30 configurations spanning L ∈ {2, 4, 6, 8, 10, 12} and d ∈ {64, 128, 256, 512, 1024}, mean ECE remains within [1.10, 1.22]%, and per-configuration standard deviations fall within [0.71, 0.97]. The chosen configuration (L = 6, d = 256) achieves a mean ECE of 1.14 ± 0.74%, which reflects an arbitrary selection of hyperparameters to avoid overfitting to the evaluation data. Figure 1 summarizes the results of the mean ECE for the entire grid. Notice that the relative ranking against the baselines remains stable across the tested grid, and that the selected configuration is not optimized. All experiments were conducted on a single NVIDIA RTX 3090 GPU with 24GB VRAM and 32GB system RAM using PyTorch. We report ECE with M=15 bins, as used in [Guo et al., 2017], averaged over multiple seeds with 95% confidence intervals, as standard.

5 Results

This section demonstrates that: (1) RGCL achieves strong top-label calibration across architectures and datasets (Section 5.1), (2) random layer sampling matches or exceeds optimized selection (Section 5.2), and (3) RGCC provides an efficient alternative with competitive results (Section 5.3).

5.1 RGCL Achieves Strong Top-Label Calibration

To evaluate the calibration performance of RGCL, we compare it against two families of single-model post-hoc calibrators. Logit-based methods: Temperature Scaling (TS) [Guo et al., 2017], Top Label Isotonic Regression [Zadrozny and Elkan, 2002; Gupta and Ramdas, 2022], Platt Scaling [Platt, 2000], and Beta Calibration [Kull et al., 2017]. Featurebased methods: Fast Separation [Chouraqui et al., 2022] (geometric separation in pixel space), DAC [Tomani et al., 2023]

(density-aware calibration with architecture-specific layers), and TULIP [Benkert et al., 2024] (layered intermediate predictions) 1 . We additionally report Deep Ensembles [Lakshminarayanan et al., 2017] as a high-cost uncertainty reference.

Table 1 shows the ECE of these algorithms on the evaluated models and datasets. As can be observed, RGCL consistently achieves the lowest or near-lowest ECE across the considered datasets and architectures. Specifically, RGCL achieves an average rank of ∼1.71 across all configurations (∼1.21 when RGCC is excluded), ranking first or second in 12 of 14 settings. Relative to uncalibrated predictions, RGCL reduces ECE by 78% on average, and by up to 97% on CIFAR100 DINOv2. Against the best non-RGC baseline, RGCL achieves an average improvement of 12% and up to 19%.

Beyond ECE. Since RGC calibrates top-label confidence [Gupta and Ramdas, 2022], ECE is our primary metric. However, we also evaluate Adaptive ECE [Nixon et al., 2019] and top-label MCE to assess whether the conclusions remain stable across related binning-based calibration metrics. On Adaptive ECE, both RGCL and RGCC achieve an average rank of approximately 1.57 against non-RGC baselines, with top-three placement in 13 and 12 out of 14 evaluated configurations, respectively. On MCE, RGCC slightly improves over RGCL in average rank (2.79 vs. 3.00), and both methods rank in the top-three in 9 of 14 configurations. We conclude that the selected metric is representative, and we obtain similar results with other metrics.

1 The experimental results for TULIP are taken directly from [Benkert et al., 2024].

5.2 SamplingMatches Optimal Layer Selection

We compare RGCL and RGCC with geometric calibrators that rely on optimized layer selection, namely DAC and TULIP, denoted GC(DAC) and GC(TULIP). Figure 3 reports ECE normalized relative to RGCL. The differences cluster near zero and mostly fall within the δ = 0.5 percentagepoint equivalence band suggesting that RGCL and RGCC achieve equivalent calibration performance to carefully selecting layer configurations.

Table 2 reports the corresponding numerical results. To formally assess equivalence, we perform two one-sided tests (TOST) [Schuirmann, 1987] with margin δ=0.5 percentage points. The test establishes equivalence in 10 of 13 modeldataset configurations, and in no configuration is RGCL found to be significantly worse than DAC- or TULIP-based layer selection. Taken together, these results show that our randomized sampling strategy can replace carefully tuned layer selection without a statistically significant degradation in calibration performance.

5.3 RGCC Provides Comparable Calibration at Lower Preprocessing Cost

This section compares RGCL and RGCC using TOST equivalence testing, with results reported in Table 2. Of the 13 dataset and model combinations, 9 establish formal equivalence at margin δ = 0.5 percentage points. The point estimates mildly favor RGCL on CIFAR-10 and CIFAR-100 on average, whereas RGCC achieves lower ECE on average on Tiny-ImageNet. The remaining configurations do not establish equivalence, primarily due to higher variance or fewer paired trials. Overall, the differences are small, and combined with RGCC's lower preprocessing cost (Section 5.5), this makes RGCC an attractive option for resource-constrained deployment.

5.4 Why RGCL Works

At first glance, the strong performance of RGCL and RGCC may seem surprising. Unlike prior work, our method does not rely on explicit per-layer weighting, even though uniformly weighting layers is generally suboptimal when many layers are uninformative. We show that layers exhibiting strong geometric separation also tend to have disproportionately large L2 norms. As a result, once such a layer is sampled, it naturally dominates the aggregation.

Figure 2 plots the average L2 norm of pooled feature vectors, ∥vℓ(x)∥2, across layers for three architectures on CIFAR-100. We observe a consistent increase in norm magnitude from early to late layers: 5.5× for ResNet-152, 22.3× for DINOv2-Large (despite a constant embedding dimension), and 34.6× for DenseNet-121 (likely driven by dense feature concatenation). In DINOv2-Large, the embedding dimension is fixed, and we still see larger norms in important layers. When projected vectors are summed, layers with larger norms therefore contribute disproportionately to the induced Euclidean geometry, effectively emphasizing later blocks without requiring explicit layer weighting. We emphasize that this is an empirical explanation rather than a worstcase guarantee: in architectures where late-layer norms do not dominate, the implicit weighting effect may be weaker or distributed more uniformly across layers.

This implicit emphasis on a small number of informative layers motivates the second design choice of our method. Once the layers are selected, we compress them into a compact representation with drastically fewer coordinates. The effectiveness of this compression is consistent with growing evidence that learned representations exhibit substantial distributed redundancy. For example, Nanda et al. [Nanda et al., 2023] demonstrate that randomly selected neuron subsets preserve much of a layer's representational power.

5.5 Computational Efficiency

In this section, we evaluate the computational overhead of our proposed methods. We consider two benchmarks: the offline preprocessing time and the online inference throughput.

First, we evaluate the offline preprocessing time required by our methods. These results are shown in Figure 4. As expected, RGCL requires more preprocessing time than the alternative methods. RGCC substantially reduces this cost; however, the preprocessing time remains higher than that of prior work. This overhead constitutes a limitation of our approach, but it is incurred only once during calibration setup and does not affect inference-time performance.

Second, we evaluate the number of confidence estimates produced per second on each dataset. Figure 5 reports these results. We observe that DAC is considerably faster than both RGCL and RGCC. The two variants attain nearly identical inference speeds, as they execute the same geometric scoring procedure on slightly different feature representations. Fast Separation [Chouraqui et al., 2022] is slower still, and its throughput depends directly on the input dimensionality. In contrast, our methods project inputs into a fixed-dimensional random subspace, yielding a constant computational cost independent of the original input size.

The main takeaway from these experiments is the tradeoff inherent in our approach and in geometric calibration methods more broadly. Unlike purely logit-based calibrators, RGCL and RGCC require an offline preprocessing stage for feature extraction and nearest-neighbor index construction, which can be costly when the calibration set or data distribution changes frequently. However, once this index is built, both variants support several hundred confidence estimates per second, making them compatible with real-time vision workloads such as video-rate inference. Thus, RGC is best suited to settings with relatively stable calibration data, where improved top-label calibration justifies additional offline preprocessing and moderate online overhead.

6 Discussion

Our work contributes to the ongoing line of research on geometric confidence calibration. We demonstrate that explicit layer selection and weighting can be avoided by adopting layer-based or coordinate-based sampling schemes, and that the dimensionality of the geometric feature space can be drastically reduced without sacrificing performance. These findings reinforce observations by Nanda et al. [Nanda et al., 2023] regarding the high degree of redundancy present in late-stage feature representations.

Building on these insights, we introduce a geometric confidence calibration method. The method assesses how close an input representation lies to the boundary of the class-induced geometry.

We further show that our approach outperforms several recently proposed geometric confidence calibrators, including DAC [Tomani et al., 2023], TULIP [Benkert et al., 2024], and Separation [Chouraqui et al., 2022], establishing a strong empirical contribution to the literature on confidence estimation. Through extensive evaluation, we analyze both the strengths and limitations of our method, provide insight into its effectiveness, and position its computational overhead within the broader literature, exposing the trade-offs involved.

Our evaluation is limited to in-distribution imageclassification benchmarks.

Evaluating RGC under corruptions, domain shift, and nonvision modalities is an important direction for future work.

Looking forward, our results suggest that future geometric calibrators may benefit from placing less emphasis on explicit layer selection and weighting. Such design choices can introduce additional adaptivity to specific architectures or datasets, potentially limiting transfer across models. In contrast, randomized sampling strategies, such as the two variants proposed in this work, offer a simple and architecture-agnostic route for constructing informative geometric feature spaces.

An additional promising direction is the approximation of reduced semantic feature spaces induced by successful geometric calibrators using smaller neural networks. We hypothesize that such networks could produce embeddings better suited for semantic caching, potentially leading to improved efficiency and performance.