Static operators (max/average). For a window ℛ with activations {xi}i∈ℛ, (1)yavg=1|ℛ|∑i∈ℛxi,ymax=maxi∈ℛxi.

As shown in Fig. 2a, max pooling selects the largest activation in each window, accentuating strong responses and providing limited shift invariance as in Eq. (1), often leading to aliasing artifacts [30]. During backpropagation, the gradient is routed only to the argmax entry, yielding sparse updates but increasing sensitivity to outliers. In contrast, as shown in Fig. 2b, average pooling spreads gradients uniformly across entries and stabilizes optimization, though it can oversmooth edges and lose boundary-level evidence [7,29].

Generalized-mean (L_p) pooling. The generalized mean (2)yLp = (1|ℛ|∑i∈ℛ|xi|p)1/p,p>0,controls pooling sharpness with a single parameter p [21–23]. In Eq. (2) when p=1, it equals average pooling; for p→∞, it approximates max pooling; and for 0<p<1, it damps outliers like a geometric mean. As illustrated in Fig. 3a, the normalized L2 case averages squared responses and then takes the square root.

In practice, power-mean pooling benefits from proper normalization for both accuracy and numerical stability. Prior work on Lp/GeM reports improved performance when the pooled output is normalized (e.g., power/mean normalization or downstream normalization layers) [23]. More broadly, Batch Normalization (BN) is known to stabilize training by smoothing the loss landscape and conditioning gradients [31,32].

Order-statistic pooling. This family summarizes responses by rank rather than magnitude. As illustrated in Fig. 3b, Top-K pooling averages the K largest activations (e.g., Top-3 average pooling on a 2×2 neighborhood selects the three largest values and averages them). In Fig. 3c, a trimmed mean discards the T largest and T smallest values (e.g., T=1 on a 2×2 window, i.e., T-1 trimmed pooling), then averages the remainder. Quantile pooling instead selects a specific order statistic, such as the median. With small windows, these rank-based selection masks can change discretely when ranks swap, yielding piecewise-smooth behavior [7].

T-max-avg pooling. This hybrid keeps the maximum if the Top-K responses exceed a threshold T; otherwise, it falls back to the average of Top-K [33]. It balances noise-robustness and peak preservation, though with small windows, it often degenerates to simpler forms.

Unlike value-only reductions, membership-based pooling explicitly represents local ambiguity by assigning each activation a degree of belonging in [0, 1], [26].

Type-1 (membership/rule–driven). Given activations and fixed/learned memberships, pooling is performed as a weighted average. As illustrated in Fig. 3d, learned membership functions (with centers at approximately 0.2, 0.5, and 0.8 in this example) assign weights to entries according to their degrees of belonging before aggregation. This operator is simple and differentiable, but often depends on hand-crafted or task-tuned membership functions, which can limit generality [34,35].

Fuzzy logic has also been integrated into CNN pooling mechanisms and clustering frameworks to enhance feature preservation [36]. FP-CNN [37] introduced a fuzzy pooling operator that adaptively combines max and average pooling through a membership function derived from local feature intensities. Specifically, each pooling region computes a fuzzy membership μ and aggregates responses as μ⋅max+(1−μ)⋅avg, thus balancing sharpness and smoothness while mitigating spatial information loss. Unlike this hybrid formulation, our proposed method generalizes the pooling process through a trainable, membership-driven Lp aggregation that adjusts its exponent per location, offering a more flexible and differentiable fuzzy adaptation mechanism.

Type-2 (uncertain memberships). Here, memberships themselves are uncertain, modeled as intervals with type-reduction prior to defuzzification [38]. It can improve robustness under distribution shifts, but adds complexity and hyperparameters.

Position of this work. Type-1 and Type-2 show the importance of uncertainty-aware pooling, but each faces practical challenges. Our approach addresses these by estimating memberships with FCM and aggregating with cluster-specific exponents, combining adaptability with drop-in compatibility.

Fig. 4 summarizes the workflow of the proposed fuzzy clustering-driven soft pooling layer. Given an input feature map, we compute fuzzy memberships per sample and per location via FCM, using cluster centers shared across the batch. We then realize two pooling variants: (a) Membership Averaging and (b) Membership Maxing. Both variants ultimately perform a normalized generalized-mean (Lp) aggregation whose exponent is adapted per spatial location.

In practice, the proposed fuzzy pooling layer directly follows each convolutional block, taking its feature map as input without any intermediate transformation. The output retains the same channel dimension and is passed to the next convolution or fully connected layer. Thus, it functions as a drop-in replacement for conventional Max or Average pooling within standard CNN architectures.

Assume a feature tensor X∈RB×H×W×C and let xb,ij∈RC denote the C-dimensional feature at spatial location (i,j) in sample b. And also let {ck}k=1K denote trainable cluster centers in RC (shared across the batch). Define the per-sample, per-location, per-cluster distance as in Eq. (3). (3)db,ij,k = ‖xb,ij−ck‖2+ε,where ε>0 avoids division by zero. With fuzzifier m>1, the memberships are defined following the standard FCM formulation [28] as in Eq. (4). (4)ub,ij,k = (∑ℓ=1K(db,ij,kdb,ij,ℓ)2m−1)−1,s.t.∑k=1Kub,ij,k=1,yielding a membership tensor U∈[0,1]B×H×W×K. The centers {ck} are optimized end-to-end via backpropagation.

Each cluster k is associated with a learnable exponent pk. We constrain pk∈[pmin,pmax] via a squashed parameterization as in Eq. (5). (5)pk = pmin+σ(p~k)(pmax−pmin),where p~k is the unbounded learnable parameter and σ(⋅) is the sigmoid function.

Given the memberships {ub,ij,k} and cluster exponents {pk}, the per-location exponent pb,ij is determined by one of the following two schemes as in Eqs. (6) and (7). (6)(a) Membership Averaging:pb,ij = ∑k=1Kub,ij,kpk, (7)(b) Membership Maxing:pb,ij = pk⋆,where k⋆ = arg maxkub,ij,k.

Interpretation of cluster exponents. Implicitly, clusters act as latent pattern types (e.g., edges, textures, flat regions). Learning a distinct pk per type lets the layer tune aggregation sharpness to the local pattern (e.g., larger pk near salient edges, smaller pk in smooth areas) with low overhead.

Commonality vs. difference. Both rules rely on the same memberships U and type-wise exponents {pk}. Averaging is smooth and differentiable, while Maxing is simpler but introduces a discrete arg⁡max; in practice we use Averaging as default and report Maxing as an ablation.

Pooling is applied per channel. Let Ωij denote the pooling window centered at (i,j) with cardinality |Ωij|. Using the computed exponent pb,ij, the output is defined as in Eq. (8). (8)yb,ijc = (1|Ωij|∑(m,n)∈Ωij|Xb,mnc|pb,ij)1/pb,ij,where Xb,mnc denotes the input scalar activation at location (m,n) and channel c.

Optionally, a membership-weighted variant replaces the uniform average (1/|Ωij|) with normalized weights wmn(b,ij)≥0 satisfying ∑(m,n)∈Ωijwmn(b,ij)=1.

After the proposed fuzzy pooling, a BN-style normalization is appended to stabilize both feature scales and gradient dynamics. In fuzzy clustering-based pooling, the membership distributions {ub,ij,k} evolve spatially and temporally during training, and their interaction with the adaptive exponents pb,ij can amplify response variance within each mini-batch. This phenomenon is analogous to the local-rule dominance observed in fuzzy systems under non-uniform data distributions [34,35].

Applying BN immediately after pooling normalizes channel-wise statistics, effectively damping variance propagation and smoothing gradient flow across iterations. From a theoretical perspective, the adaptive Lp operator embedded in the proposed fuzzy pooling acts as a non-linear scaling mechanism whose sensitivity to input magnitude increases with p. BN counteracts this by rescaling activations toward unit variance, thereby maintaining consistent learning dynamics regardless of the spatially varying sharpness pb,ij. This interpretation aligns with prior findings that BN smooths the optimization landscape and stabilizes gradient propagation in deep networks [31,32].

Empirical evidence of this stabilizing effect is presented in Appendix A. Across all architectures (LeNet-5, AlexNet, and VGG-16), the BN-applied variants consistently achieved 3%–8% higher accuracy and weighted F1 scores with reduced variance, demonstrating that BN functions as a structural stabilizer within the proposed fuzzy-adaptive pooling rather than merely as a statistical normalization step. All experiments were conducted with a batch size of 32, providing sufficient samples for reliable batch statistics while avoiding the instability often observed in small-batch BN.

To clarify the computation process of the proposed fuzzy pooling layer, Fig. 5 visualizes the step-by-step operation from clustering to adaptive pooling. An input feature map is clustered by FCM into K=3 latent types, yielding a membership map U. Two paths are illustrated: (a) Membership Averaging, where the cluster-specific exponents p=[1,1.5,2] are averaged with memberships to form pij, then used for normalized Lpij pooling; (b) Membership Maxing, where the argmax membership selects a cluster per location, followed by pooling with the corresponding pij. In both cases, BN-style normalization is applied after pooling. For reference, conventional average and max pooling outputs are also shown.

To further highlight the difference from conventional pooling, Fig. 6 presents the visualized results after the 1st and 2nd pooling stages using various pooling methods. While Average and L2-norm pooling tend to smooth out detailed edges, and Max pooling overemphasizes only the highest activations, the proposed fuzzy pooling variants (Mavg and Mmax) adaptively regulate contrast based on the learned exponents p=[5,0.2,0.2]. Assuming the feature activations are normalized in [0,1], regions associated with clusters having pk>1 are suppressed (weakened), whereas those with pk<1 are enhanced (highlighted). Consequently, the darkest and brightest clusters become more prominent, while intermediate tones are attenuated, leading to stronger edge delineation and higher local contrast.

This two-step illustration—computation flow followed by visual comparison—clarifies how the proposed fuzzy pooling mechanism translates its adaptive exponent control into perceivable structural differences. The enhanced local contrast observed here provides a visual rationale for the superior discriminative performance demonstrated in Section 4.3 and supports the need for BN stabilization discussed in Section 3.5. For further visualizations concerning the effect of the cluster count K and different integration strategies, please refer to Appendix B.

The proposed fuzzy pooling layer integrates three computational components: (1) membership estimation based on feature-to-center distances defined in Eq. (3), (2) adaptive Lp-norm aggregation guided by the learned exponents, and (3) BN-style normalization for stabilization. Each part contributes differently to the overall computational cost, which we analyze below.

Note that a classical FCM algorithm requires iterative updates with a typical complexity of 𝒪(NK2CI) or 𝒪(NKCI) for improved variants [39], where I is the number of iterations. By contrast, the proposed pooling layer performs a single-pass computation without iteration.

Membership computation. Using the distance formulation in Eq. (3), each spatial location computes its distances to K cluster centers and normalizes them according to the membership rule in Eq. (4). This operation requires 𝒪(CK) computations per location, and thus 𝒪(NCK) for the entire feature map, where N=H×W. Since cluster centers are optimized by backpropagation rather than iterative FCM updates, no additional loop over iterations is needed, keeping the process single-pass.

Adaptive pooling and normalization. Once the memberships are obtained, the per-location exponent pb,ij is computed through either the weighted averaging rule in Eq. (6) or the hard selection rule in Eq. (7). Both require at most 𝒪(NK) operations. Subsequent adaptive Lp pooling in Eq. (8) and BN-style normalization are performed channel-wise, each with 𝒪(NC) complexity.

Overall complexity. Summing these components, the overall computational cost of the proposed layer is 𝒪(NCK), dominated by the membership computation step. For comparison, standard average or max pooling has 𝒪(NC) complexity. Therefore, the proposed fuzzy pooling introduces only a small linear factor of K to model fuzzy memberships and adaptive aggregation strength, while maintaining computational feasibility for modern CNN architectures.

Empirical inference efficiency. To complement the asymptotic analysis, we measured the actual inference time per batch (32 samples) across representative CNNs and pooling methods. Table 1 summarizes the results averaged over five runs.

The inference latency of the proposed fuzzy pooling (Mavg and Mmax) is generally comparable to that of the Type-1 fuzzy baseline (FP) on smaller networks, while being substantially faster on the deeper VGG-16 architecture (e.g., ∼2.5× speedup over FP). Both variants are also significantly more efficient than the sorting-intensive T-max-avg operator. Although slightly slower than classical average or max pooling due to membership estimation, the proposed methods maintain a favorable trade-off between representational robustness and computational efficiency. Importantly, the gap between Mavg and Mmax remains within statistical variance, suggesting that their inference complexity is nearly identical despite their different exponent selection rules. This confirms the proposed design’s suitability for real-time or on-device deployment across CNN architectures of various depths.

We evaluate the pooling layers defined in Section 3 in two distinct experimental phases against seven alternatives.

Hardware configuration.

All experiments were conducted on a workstation equipped with an Intel Core i9-13900F CPU (24 cores, 32 threads), an NVIDIA RTX 4090 GPU (24 GB VRAM), and 64 GB of main memory. TensorFlow (ver. 2.12) was used with the NVIDIA-recommended configuration for the RTX 4090, including CUDA 12.x and cuDNN 8.x libraries. The batch size was fixed at 32 across all experiments to ensure consistent batch-normalization statistics and reproducible inference-time comparisons.

Proposed methods. Mavg: Membership-Averaging fuzzy pooling; Mmax: Membership-Maxing fuzzy pooling. Both variants incorporate the BN-style stabilization described in Section 3 (ablation study provided in Appendix A).

Baselines. To validate effectiveness, we compare against seven pooling strategies: Max and Avg pooling (standard); Lp: generalized-mean pooling with learnable p [21]; T-max-avg: thresholded Top-K hybrid discussed in Section 2.1 [33]; Type-1 fixed: Type-1 fuzzy pooling with a fixed membership function (e.g., triangular/Gaussian) [34]; Type-1 learnable: Type-1 fuzzy pooling with trainable membership parameters; and FP: the fuzzy-pooling module from FP-CNN [37], representing a prior convolution-integrated fuzzy pooling framework.

Backbones and insertion points.

We use three CNN backbones, as illustrated in Fig. 7: (a) LeNet-5 [1], (b) AlexNet [2], and (c) VGG-16 [9]. In all models, the native pooling layers (highlighted in green) are replaced one-for-one by each candidate pooling operator, preserving the original window size, stride, and padding configuration.

Why hold-out (HO) instead of k-fold CV.

While k-fold cross-validation is standard practice, we observed that several traditional pooling baselines occasionally exhibited numerical instability or convergence failure (e.g., loss divergence or stagnation) under identical training protocols. Since such instability renders the corresponding folds statistically unreliable and practically undeployable, including them introduces unnecessary volatility into the comparison. Therefore, we adopt a repeated hold-out evaluation protocol and aggregate results only from successfully converged runs to ensure a fair assessment of peak capability (convergence criteria detailed below).

Experiment 1 (Multi-backbone comparison).

This phase evaluates general classification performance across diverse domains.

Datasets: CIFAR-10 and CIFAR-100 [40], LFW (subset) [41], STL-10 [42], and ImageNette (a subset of ImageNet [43]), as summarized in Table 2.

Experiment 2 (Low-resolution, low-data probe).

This phase probes robustness under data scarcity using lightweight models.

Backbone: LeNet-5 only (input resized to 28×28).

Repeated HO with convergence filtering.

For each (dataset, backbone, pooling) configuration, we draw independent random HO partitions and train until obtaining a fixed number of converged runs: 10 runs for Experiment 1 and 5 runs for Experiment 2. Runs that do not converge (e.g., due to divergence or instability) are discarded and retried with a new random seed and split. We report the mean ± standard deviation calculated over these retained, successful runs.

Preprocessing and training.

Inputs are min-max normalized to [0,1], and targets use one-hot encoding with a label smoothing factor of 0.25. Training employs the Adam optimizer with a learning rate of 4×10−4 (decaying by 0.1 on plateaus) for 100 epochs, utilizing categorical cross-entropy loss. Experiment 1 resolutions vary by backbone: LeNet-5 uses 32×32 RGB (first conv adapted to 3 channels), while AlexNet and VGG-16 use 224×224. Experiment 2 uses native 28×28 grayscale for LeNet-5. Unless otherwise noted, the number of clusters K in Mavg/Mmax is set equal to the number of classes for the dataset.

Hyperparameter setting for m and K.

The fuzzifier was fixed at m=2.0 in all experiments, following common practice in FCM-based models [28], which provides stable and moderately soft memberships for visual feature maps.

To determine a suitable range for the number of clusters K, we conducted preliminary experiments under conditions similar to the two main setups (Training ratio Tr=0.6 in Experiment 1 and Tr=0.001 in Experiment 2) on representative datasets. Varying K from 2 to 9 revealed that the proposed method is generally robust to K, showing no statistically significant performance degradation across this range.

In the main experiments, to ensure optimal model selection, K was determined based on the validation loss during the stabilization phase of training—the intermediate stage where training and validation losses oscillate around equilibrium before overfitting begins. This phase, which follows the initial rapid convergence and precedes the divergence between training and validation losses, best reflects the model’s saturated generalization capability. Accordingly, we monitored the validation loss over the last 10 epochs of this phase and selected the K yielding the lowest validation loss. This procedure provides a data-driven and reproducible determination of K, avoiding bias from transient states.

Experiment 1 (Multi-backbone).

Figs. 8–13 present the accuracy and weighted F1 distributions (10 converged hold-out runs) for LeNet-5, AlexNet, and VGG-16. Across all configurations, Mavg and Mmax consistently achieve the highest medians (or tie for the top position) with narrower interquartile ranges (IQRs), indicating robust convergence. Notably, these improvements are statistically significant (Wilcoxon signed-rank test, p<0.05) against the strongest baselines in most cases. In contrast, the Type-1 fuzzy and FP-CNN baselines generally yield lower medians and larger variability, highlighting the advantage of the proposed cluster-specific exponent adaptation.

As detailed in Figs. 8 and 9, for LeNet-5, Mavg consistently outperforms Max, Avg, Lp, and T-max-avg on CIFAR-10 and CIFAR-100, with the gap particularly pronounced on CIFAR-100 given the higher class diversity. On STL-10, although the overall accuracy baseline is lower, both Mavg and Mmax retain the lead, while learnable Type-1 fuzzy and FP pooling show wider variance and unstable behavior. On LFW, Mavg attains the highest medians, though Lp and T-max-avg approach closely—suggesting that when class margins are subtle or inputs are structurally aligned, simpler pooling schemes can occasionally generalize competitively. On Imagenette, Mavg again dominates, achieving both the highest median and the tightest spread in accuracy and F1.

Referring to Figs. 10 and 11, for AlexNet, the superiority of Mavg and Mmax is also evident. On STL-10, Mmax performs best, closely followed by Mavg, both exhibiting small variance. On LFW, Lp or T-max-avg can sometimes match or slightly exceed the proposed methods, implying that under limited data and subtle inter-class separability, more complex pooling does not always guarantee gains over simpler adaptive baselines. In contrast, on Imagenette, both Mavg and Mmax clearly outperform the baselines, with significantly smaller variance across repeated runs.

As shown in Figs. 12 and 13, for VGG-16, the deeper backbone raises overall accuracy and F1 relative to LeNet-5 and AlexNet, yet Mavg consistently maintains a performance advantage—most visibly on LFW and Imagenette. While Lp and T-max-avg appear competitive in certain configurations, they exhibit wider variability and more outliers, whereas Mavg and Mmax offer stable and robust convergence.

Comparing accuracy and weighted F1 across all backbones, the relative rankings of pooling methods remain nearly identical. Weighted F1, which better accounts for class imbalance, further highlights the superiority of the proposed methods, especially on CIFAR-100 and Imagenette where the number of classes is large and intra-class variance is substantial. This indicates that membership-based pooling aggregates feature responses more effectively than either extremal selection (Max) or uniform averaging (Avg).

Statistical significance. To confirm that the observed performance gains are not due to random variation, paired two-sided Wilcoxon signed-rank tests were conducted over 10 independent runs per dataset and backbone. Horizontal bars and asterisks in Figs. 8–13 denote significance levels (∗:p<0.05, ∗∗:p<0.01, ∗∗∗:p<0.001). In nearly all cases, the proposed Mavg and Mmax achieve statistically significant improvements over both conventional (Avg, Max, Lp, T-max-avg) and fuzzy-type (Type-1, FP) pooling baselines, demonstrating that the observed advantages arise from the membership-based mechanism rather than random initialization.

In summary, Experiment 1 demonstrates that Mavg is the most consistently strong pooling method, with Mmax providing comparable or complementary benefits. Both converge reliably across diverse datasets and backbones, as evidenced by reduced variance and statistically significant improvements in most cases. While Lp or T-max-avg may serve as lightweight alternatives in constrained settings (e.g., LFW with AlexNet), membership-based pooling offers more robust and reproducible performance overall. Practically, Mavg is recommended as a default choice, whereas Mmax may be preferred when preserving high-frequency or edge-dominant features is critical, as qualitatively visualized in Appendix B.

Experiment 2 (Performance under limited supervision).

We investigate the impact of training-data scarcity by varying the fraction of training samples r∈{0.001,0.002,0.005,0.01,0.02,0.05,0.1,0.2,0.5} for LeNet-5 on MNIST and Fashion-MNIST. Figs. 14 and 15 summarize the trends in classification accuracy and weighted F1, respectively (reported as mean ± std over 5 converged HO runs).

Overall, membership-based pooling (Mavg/Mmax) consistently outperforms conventional pooling operators on both datasets. On MNIST, the advantage is evident even at extremely small training ratios (r=0.001), where Mavg and Mmax sustain an accuracy >0.65 and weighted F1 >0.66, while Avg and Max fall below 0.40 on both metrics—indicating that the proposed pooling extracts salient features even under severe supervision constraints.

As r increases, all methods improve, but the relative ordering remains stable. Mavg and Mmax exceed 0.95 accuracy and 0.93 weighted F1 by r=0.02, whereas Avg and Max lag by a significant margin (>10 percentage points). Type-1 fuzzy baselines (fixed or learnable) improve over Avg/Max but exhibit high variance, especially at small r, signaling less stable convergence.

On Fashion-MNIST—which is more challenging due to higher intra-class variability—the gaps are even more pronounced at small fractions (r≤0.005): conventional pooling shows wider standard deviation bands and degraded F1, whereas Mavg and Mmax improve steadily with narrower uncertainty bands. As the training set grows (r≥0.05), all methods approach saturation, yet the proposed methods retain a notable edge, surpassing 0.90 weighted F1 at r=0.5.

Taken together, Experiment 2 validates the robustness of membership-based pooling under limited supervision, a common real-world scenario where large annotated datasets are unavailable. By aggregating responses via soft memberships—avoiding the pitfalls of both extremal selection (Max) and uniform averaging (Avg)—the proposed pooling family offers a stronger inductive bias that translates into superior generalization, particularly under data scarcity.

Key observations. (1)

Across LeNet-5, AlexNet, and VGG-16, Mavg/Mmax typically achieve higher medians and tighter IQRs than Max/Avg/Lp/T-max-avg and both Type-1 fuzzy variants on CIFAR-100 and ImageNette, indicating simultaneous gains in accuracy and stability—critical when reproducibility matters.

Overall implications.

Membership-based pooling provides a consistent inductive bias across architectures and datasets, particularly when data are noisy, imbalanced, or scarce. While its relative advantage can diminish under strongly regularized architectures or inherently separable feature spaces (e.g., LFW with AlexNet), the method remains robust and avoids the instability observed in Type-1 fuzzy baselines. These properties make it a practical drop-in replacement for standard pooling in real-world scenarios where dataset conditions are rarely ideal.