ECA110-Pooling: A Comparative Analysis of Pooling Strategies in Convolutional Neural Networks

Abstract

Pooling strategies are fundamental to convolutional neural networks, shaping the trade-off between accuracy, robustness to spatial variations, and computational efficiency in modern visual recognition systems. In this paper, we present and validate ECA110-Pooling, a novel rule-based pooling operator inspired by elementary cellular automata. We conduct a systematic comparative study, benchmarking ECA110-Pooling against conventional pooling methods (MaxPooling, AveragePooling, MedianPooling, MinPooling, KernelPooling) as well as state-of-the-art (SOTA) architectures. Experiments on three benchmark datasets—ImageNet (subset), CIFAR-10, and Fashion-MNIST—across training horizons ranging from 20 to 50,000 epochs show that ECA110-Pooling consistently achieves higher Top-1 accuracy, lower error rates, and stronger F1-scores than traditional pooling operators, while maintaining computational efficiency comparable to MaxPooling. Moreover, when compared with SOTA models, ECA110-Pooling delivers competitive accuracy with substantially fewer parameters and reduced training time. These results establish ECA110-Pooling as a principled and validated approach to image classification, bridging the gap between fixed pooling schemes and complex deep architectures. Its interpretable, rule-based design highlights both theoretical significance and practical applicability in contexts that demand a balance of accuracy, efficiency, and scalability.

1. Introduction

Pooling layers are a key component of Convolutional Neural Networks (CNNs). Their role is to gradually shrink the size of feature maps while keeping the most important information intact. This compression makes models faster, helps them generalize better, and reduces the risk of overfitting. The idea of building networks that capture features at multiple levels dates back to Fukushima’s Neocognitron [1], and became practical with the advent of backpropagation [2,3]. Among pooling methods, MaxPooling has become the standard because it preserves the strongest signals, which boosts accuracy in large-scale image recognition tasks like ImageNet [4,5]. Still, depending too heavily on MaxPooling comes with limitations. Alternative fixed operators have been proposed to address the limitations of MaxPooling. AveragePooling captures global context but sacrifices fine-grained local detail [6], while MedianPooling improves robustness to noise and outliers, making it effective for grayscale or noisy datasets [7]. Alongside these fixed approaches, researchers have developed learnable pooling mechanisms. For instance, KernelPooling employs parameterized kernels that adaptively aggregate spatial information, tailoring pooling to task-specific distributions [8]. Other strategies—such as stochastic pooling [9] or strided convolutions that remove pooling entirely [10]—illustrate broader attempts to refine or bypass traditional downsampling. Although these methods can be powerful, they often increase computational cost and complicate training. Beyond purely data-driven designs, biologically and mathematically inspired pooling strategies are emerging as a promising frontier. The integration of Elementary Cellular Automata (ECA) rules into CNNs offers a lightweight, rule-based alternative for encoding local dependencies prior to reduction. Among these, Rule 110 is particularly notable for its proven computational universality and emergent complexity [11,12,13]. Embedding ECA transformations within CNNs enables pooling layers such as the proposed ECA110-Pooling to capture fine-grained micro-pattern interactions that conventional operators often overlook [14,15]. This approach combines theoretical rigor with practical utility, effectively bridging symbolic dynamics and deep learning. Nevertheless, systematic and controlled comparative evaluations remain scarce. Much of the CNN literature continues to rely on MaxPooling by default, often without explicit justification or consideration of task-specific requirements [16,17]. Recent surveys and benchmarking studies highlight the need to revisit these design choices, especially as modern classification pipelines increasingly face constraints of efficiency, generalization, and robustness [18,19,20].

The motivation for this study is twofold. First, it aims to rigorously compare a broad range of pooling strategies—including MaxPooling, AveragePooling, MedianPooling, MinPooling, KernelPooling, and the novel ECA110-Pooling—within a consistent experimental framework across CIFAR-10, Fashion-MNIST, and a subset of ImageNet. Second, it aims to evaluate not only predictive performance, but also computational efficiency and robustness to varying the number of training epochs. By positioning ECA110-Pooling alongside both traditional operators and state-of-the-art (SOTA) image classification baselines, this work offers a nuanced perspective on how pooling strategies shape the effectiveness and efficiency of CNN-based classification.

-

Contributions. This work is distinguished by the following contributions regarding the analysis of pooling methods that can be used in CNN neural networks:

-

Systematic comparative evaluation. We conduct a rigorously controlled comparison of six pooling operators—MaxPooling, AveragePooling, MedianPooling, MinPooling, KernelPooling, and the proposed ECA110-Pooling—within a shared CNN backbone, fixed training protocol, and identical hyperparameter settings. This design highlights the specific impact of the pooling mechanism.

-

Novel ECA110-based pooling mechanism. We introduce and formalize a pooling operator derived from Elementary Cellular Automata (Rule 110). The operator follows a compact transform–reduce paradigm, enabling the preservation of discriminative local structures with minimal computational overhead.

-

Learnable baseline for reference. The inclusion of KernelPooling as a parametric baseline ensures a fair comparison between rule-based and learnable pooling approaches, highlighting trade-offs between flexibility, accuracy, and efficiency.

-

Comprehensive benchmarking across datasets and epochs. Pooling methods are evaluated on CIFAR-10, Fashion-MNIST, and a subset of ImageNet, with training horizons ranging from 20 to 50,000 epochs. Metrics include Top-1 Accuracy, Error Rate, F1-score, per-epoch runtime, and model size.

-

Statistical and computational validation. Results are validated through statistical tests (one-way ANOVA, Tukey’s HSD, Wilcoxon signed-rank, and paired t-tests). This ensures that conclusions are both statistically robust and practically reproducible.

In summary, this study establishes ECA110-Pooling as a principled, lightweight, and competitive alternative to classical and learnable pooling mechanisms, with implications for advancing image classification across both high-capacity computational infrastructures and resource-constrained environments.

The remainder of this paper is structured as follows. Section 2 reviews related work. Section 3 introduces the theoretical foundations and pooling strategies. Section 4 describes the proposed ECA pooling method and its integration into CNN architectures. Section 5 outlines the experimental protocol, including datasets, CNN backbone, algorithmic framework, and evaluation metrics. Section 6 presents the experimental results, covering convergence studies, complexity analysis, statistical validation, and benchmarking of ECA110-Pooling against state-of-the-art methods. Section 7 discusses limitations and future directions, while Section 8 concludes the paper.

2. Related Work

Pooling operations have been widely studied in the design of Convolutional Neural Networks (CNNs) due to their central role in spatial downsampling, complexity reduction, and the promotion of translational invariance [21]. The earliest operators, MaxPooling and AveragePooling, remain dominant because of their simplicity and efficiency. However, these fixed mechanisms suffer from inherent limitations, including the loss of fine-grained details and sensitivity to noise, motivating a broad range of extensions. One line of work introduces stochasticity or adaptivity into the pooling process. Stochastic pooling selects activations in proportion to their magnitudes, providing implicit regularization that enhances generalization. Mixed pooling and gated pooling further increase flexibility by probabilistically combining or adaptively choosing between max and average pooling based on input characteristics [22]. Adaptive pooling methods such as spatial pyramid pooling and region-of-interest pooling enable the extraction of fixed-size feature representations from variable input dimensions, making them indispensable for object detection and recognition pipelines. Another prominent direction replaces static operators with learnable downsampling mechanisms. Strided convolutions have been proposed as pooling-free alternatives that preserve convolutional structure while reducing resolution [23]. Parametric pooling methods, such as $\alpha$-integration pooling [24], extend classical operators by introducing tunable parameters, while generalized pooling approaches interpolate continuously between max and average pooling [25]. These advances highlight a growing emphasis on adaptive downsampling, where the pooling function is optimized jointly with the network. Surveys confirm that such operator-level choices can significantly affect generalization and robustness, depending on data distribution and task requirements [26]. More recently, pooling has been linked to the broader trend of incorporating attention mechanisms into CNNs. Residual attention networks combine pooling with attention-driven feature selection, enhancing representational capacity in hierarchical architectures. Empirical studies emphasize the effectiveness of attention-based pooling, which aggregates features according to learned importance weights rather than fixed heuristics [27,28,29]. This paradigm situates pooling within the broader landscape of context-sensitive aggregation, narrowing the gap between CNNs and Transformer-based vision architectures. Biologically and mathematically inspired operators remain less explored but offer promising directions. For instance, Elementary Cellular Automata (ECA) provide a rule-based framework for capturing local structural dependencies in image data. Rule 110, with its proven computational universality and emergent complexity, has been adapted as a lightweight pooling mechanism (ECA110) capable of preserving micro-pattern interactions often lost in traditional pooling. Such operators bridge theoretical concepts with practical deep learning architectures, opening opportunities for interpretable yet efficient pooling designs. Complementary research has explored hybrid and biologically inspired operators, including multiscale pooling strategies [30,31,32], binary pooling with attention [33], and probabilistic pooling designs [34], further expanding the design space. Despite this progress, most prior studies have evaluated pooling variants in isolation, typically comparing a new method against only a few baselines under limited experimental conditions. Consequently, systematic large-scale benchmarks that assess multiple pooling operators within identical CNN backbones, training regimes, and datasets remain scarce. This fragmentation obscures the true trade-offs among accuracy, computational cost, and generalization. To address this gap, the present study provides a controlled and comprehensive comparative analysis of six pooling strategies—MaxPooling, AveragePooling, MedianPooling, MinPooling, KernelPooling, and the proposed ECA110-Pooling—across diverse datasets and training horizons, thereby advancing the understanding of pooling as a fundamental component of image classification models.

3. Preliminaries and Theoretical Foundations

3.1. Convolutional Neural Networks

Convolutional Neural Networks (CNNs) represent a foundational paradigm in deep learning for processing data with grid-like structures, such as images and videos. Their evolution has been shaped by architectural innovations and training methodologies that enabled deeper and more expressive models. Early work on efficient optimization, including greedy layer-wise pretraining [35], laid the groundwork for scaling neural networks prior to the advent of modern training techniques. A typical CNN is organized as a hierarchy of convolutional filters for feature extraction, interleaved with pooling or subsampling operations that reduce spatial resolution while retaining discriminative information. These downsampling mechanisms foster translational invariance, a property essential for robust visual recognition. Complementary advances, such as recurrent and memory-augmented architectures, further extended the representational capacity of neural models beyond vision tasks [36,37]. Over the past decade, CNNs have become the backbone of state-of-the-art systems in image classification, object detection, and semantic segmentation. Comprehensive surveys highlight their central role in artificial intelligence and their integration with other paradigms, including recurrent and attention-based networks [38,39]. Taken together, these advances show that CNNs function not just as feature extractors, but as a foundational component of modern deep learning.

3.2. Pooling Strategies: Formal Definitions

Let $\mathbf{x}\in {\mathbb{R}}^{H\times W\times C}$ denote an input feature map, where H, W, and C represent height, width, and the number of channels, respectively. For a pooling window ${\Omega }_{i,j}$ of size $k\times k$, centered (or positioned) at spatial coordinates $(i,j)$ in channel c, several pooling strategies can be formally defined as follows.

• MaxPooling:

  $$y_{i,j,c}=\underset{(u,v)\in {\Omega }_{i,j}}{\max }{x}_{u,v,c}.$$

  (1)

  This operator selects the maximum activation within the local neighborhood, thereby preserving the strongest feature responses.

• AveragePooling:

  $$y_{i,j,c}={\displaystyle \frac{1}{|{\Omega }_{i,j}|}}\sum _{(u,v)\in {\Omega }_{i,j}}{x}_{u,v,c},$$

  (2)

  where $|{\Omega }_{i,j}|=k^2$. AveragePooling captures the mean activation, emphasizing global contextual information while reducing sensitivity to individual variations.

• MedianPooling:

  $$y_{i,j,c}=\mathrm{median}\{x_{u,v,c}\mid (u,v)\in {\Omega }_{i,j}\},$$

  (3)

  which computes the statistical median of activations in the pooling region, offering robustness to local noise and outliers.

• MinPooling:

  $$y_{i,j,c}=\underset{(u,v)\in {\Omega }_{i,j}}{\min }{x}_{u,v,c}.$$

  (4)

  This strategy retains the weakest local activations and is mainly used in comparative evaluations as a lower baseline.

• KernelPooling:

KernelPooling represents an adaptive pooling mechanism in which the aggregation of local activations is guided by learnable spatial kernels. Unlike fixed pooling operators such as MaxPooling or AveragePooling, where the aggregation rule is predetermined, KernelPooling jointly optimizes the kernel weights with the rest of the Convolutional Neural Network during training, thereby enabling task-specific spatial information retention. Formally, let $\mathbf{x}\in {\mathbb{R}}^{H\times W\times C}$ denote an input feature map with C channels. Each channel c is associated with a learnable pooling kernel ${\mathbf{W}}^{\left(c\right)}\in {\mathbb{R}}^{k\times k}$, where k is the spatial extent of the pooling window. For each pooling region ${\Omega }_{i,j}$, positioned at location $(i,j)$, the downsampled activation is defined as:

$$y_{i,j,c}=\sum _{(u,v)\in {\Omega }_{i,j}}{\mathbf{W}}_{u-i,v-j}^{\left(c\right)}·x_{u,v,c},$$

(5)

with stride s controlling the sampling rate across the feature map. This formulation unifies the concepts of filtering and subsampling within a single operation, allowing the network to learn optimal spatial aggregation patterns that balance feature selectivity and robustness to intra-class variability.

The pseudocode implementation in Algorithm 1 summarizes the iterative computation of downsampled activations. From a computational perspective, KernelPooling introduces an additional parameterization proportional to $k^2·C$, which slightly increases training time per epoch compared to non-learnable pooling operators. Nevertheless, this overhead is often compensated by improved generalization performance, particularly in domains where the spatial distribution of discriminative features is complex and non-uniform.

Algorithm 1: KernelPooling ($k\times k$ kernel, stride s)

4. ECA110-Based Pooling Mechanism for CNNs

4.1. Definition of ECA110-Pooling

The proposed ECA110-based pooling mechanism is inspired by the theoretical framework of Elementary Cellular Automata (ECA), with particular emphasis on Rule 110, which is renowned for its computational universality and emergent structural complexity. Unlike conventional pooling operators—such as MaxPooling or AveragePooling—that directly apply a reduction over local receptive fields, ECA110-based pooling introduces a two-stage transform–reduce procedure. In this formulation, a deterministic cellular automaton transformation is first applied to the local neighborhood, followed by dimensionality reduction.

Formally, given a pooling window ${\Omega }_{i,j}$ in channel c, activations are first rearranged into a one-dimensional vector:

$$\mathbf{z}=\mathrm{flatten}\left(\{x_{u,v,c}\mid (u,v)\in {\Omega }_{i,j}\}\right).$$

(6)

The evolution function $f_{110}$, corresponding to ECA Rule 110, is then applied to $\mathbf{z}$, yielding a transformed sequence ${\mathbf{z}}^{\prime }$ that encodes local structural dependencies:

$${\mathbf{z}}^{\prime }=f_{110}\left(\mathbf{z}\right).$$

(7)

Finally, the pooled output is computed as the normalized sum:

$$y_{i,j,c}={\displaystyle \frac{1}{|{\mathbf{z}}^{\prime }|}}\sum _{k=1}^{|{\mathbf{z}}^{\prime }|}{z}_k^{\prime }.$$

(8)

4.2. Algorithm: ECA110-Pooling (Elementary Cellular Automaton Rule 110 Operator)

The ECA110 pooling operator (defined in the Algorithm 2) processes each local window in two stages: (i) a rule–based binary transformation that captures local interactions via the Elementary Cellular Automaton Rule 110, followed by (ii) a normalized-sum reduction. For each channel c and window ${\Omega }_{i,j}$ (sampled with stride s), the feature values are flattened, binarized with respect to a threshold $\tau$, evolved once (or for a fixed number of steps) under Rule 110, and then aggregated by averaging the transformed states. Further details on thresholding can be found in [40,41,42].

Indicator function. The operator $\mathbf{1}[·]$ acts elementwise on a vector and returns a binary vector:

$${\left(\mathbf{1}[\mathbf{z}\ge \tau ]\right)}_k=\left\{\begin{array}{cc}1,\hfill & z_k\ge \tau ,\hfill \\ 0,\hfill & z_k<\tau ,\hfill \end{array}\right.k=1,\dots ,\left|\mathbf{z}\right|.$$

Algorithm 2: ECA110-Pooling (window $\Omega$, stride s)

Typical choices for $\tau$ include the local mean or median of the window, or a fixed hyperparameter shared across windows. The parameter T denotes the number of iterations of Rule 110 applied to the binarized vector ${\mathbf{z}}_b$, with $T=1$ used as the default in our experiments. The function $f_{110}(·)$ denotes the iterative application of Rule 110, an Elementary Cellular Automaton (ECA) characterized by its local update rule acting on triplets of binary states. Specifically (

Table 1. Transition table for ECA Rule 110. Each triplet $(l,p,r)$ of neighboring binary states is mapped to a new state.

Triplet $(\mathit{l},\mathit{p},\mathit{r})$	111	110	101	100	011	010	001	000
New state	0	1	1	0	1	1	1	0

), ECA 110 maps each triplet $(l,p,r)\in {\{0,1\}}^3$ to a new state according to the transition rule encoded by the binary pattern ${01101110}_2$ (110 in decimal). This automaton is notable for its computational universality and emergent structural complexity. In our framework, $f_{110}\left({\mathbf{z}}_b\right)$ applies the update rule T times over the one-dimensional sequence ${\mathbf{z}}_b$, with a deterministic scan order induced by flatten$(·)$. Boundary handling (fixed zeros) is consistently enforced across experiments.

4.3. Main Steps of ECA110-Pooling on 3 × 3 Window

For a $3\times 3$ receptive field, ECA110-based pooling proceeds through the following steps (see Figure 1):

• Flattening: The activations are extracted and arranged into a one-dimensional vector $\mathbf{z}\in {\mathbb{R}}^9$.
• Binarization: Elements of $\mathbf{z}$ are mapped into binary states via thresholding (relative to mean or median), producing ${\mathbf{z}}_b\in {\{0,1\}}^9$.
• Application of Rule 110: The binary sequence ${\mathbf{z}}_b$ evolves according to the local update rule $f_{110}$, generating ${\mathbf{z}}^{\prime }\in {\{0,1\}}^9$.
• Reduction: The normalized sum of ${\mathbf{z}}^{\prime }$ provides the final pooled activation.

• Illustrative Example of ECA110 Pooling on a $3\times 3$ window.

Consider the following local window extracted from a feature map (channel c):

$${\Omega }_{i,j}=\left[\begin{array}{ccc}0.2& 0.8& 0.4\\ 0.5& 0.9& 0.1\\ 0.3& 0.7& 0.6\end{array}\right].$$

• Flattening. The window is rearranged into a one-dimensional vector:

  $$\mathbf{z}=[0.2,0.8,0.4,0.5,0.9,0.1,0.3,0.7,0.6].$$
• Binarization. Using the mean of the window ($\mu =0.5$) as threshold, values $>\mu$ are mapped to 1 and those $\le \mu$ to 0:

  $${\mathbf{z}}_b=[0,1,0,0,1,0,0,1,1].$$
• Application of Rule 110. The binary sequence ${\mathbf{z}}_b$ is evolved according to the update function $f_{110}$. For illustration, after one iteration step (we use zero-padded synchronous updates under Rule 110) the transformed sequence is:

  $${\mathbf{z}}^{\prime }=[1,1,0,1,1,0,1,1,1].$$
• Reduction by normalized summation. The final pooled activation is computed as:

  $$y_{i,j,c}={\displaystyle \frac{1}{9}}\sum _{k=1}^9{z}_k^{\prime }={\displaystyle \frac{1}{9}}(1+1+0+1+1+0+1+1+1)={\displaystyle \frac{7}{9}}\approx 0.78.$$

Thus, the output of ECA110 pooling for this $3\times 3$ window is $y_{i,j,c}\approx 0.78$. This demonstrates how the operator embeds a deterministic rule-based transformation prior to normalized reduction, thereby encoding non-linear structural dependencies before aggregation.

4.4. Ablations on CIFAR-10 at 10,000 Epochs and Windows of Size 3 × 3

To better understand the contribution of individual design choices, we performed an ablation study on CIFAR-10 at 10,000 training epochs, keeping all other training settings fixed. We report Top-1 accuracy under controlled variations of three factors: (i) the threshold parameter $\tau$, (ii) the choice of ECA rule, and (iii) the number of transformation steps T. The results of these experiments are summarized in

Table 2. The ablation study on CIFAR-10 at 10,000 epochs (Top-1 accuracy %).

Ablation	Study Variant	Top-1 Accuracy	$\mathbf{\Delta }$(diff.)
Threshold $\tau$	Mean (default)	93.0	(ref)
	Median	92.9	$-0.1$
	Fixed (0.5)	92.8	$-0.2$
ECA rule	ECA 110	93.0	(ref)
	ECA 90	92.6	$-0.4$
	ECA 30	92.5	$-0.5$
	ECA 184	92.6	$-0.4$
Steps T	0 (no transform)	92.0	$-1.0$
	1	93.0	(ref)
	2	93.0	≈0
	3	92.9	$-0.1$

.

• Statistical Significance. A one-way ANOVA ($\alpha =0.05$) revealed a significant main effect of the pooling variant on accuracy across all ablation settings ($p<0.05$). Based on these results, the recommended configuration is to employ the local-mean thresholding criterion, adopt the ECA110 rule, and, in general, utilize a single evolution step ($T=1$).

Observation 1

(Alternative Reduction Strategies for ECA110-Pooling). While the normalized sum (mean pooling) is the default reduction strategy in ECA110-Pooling, several alternatives can be employed depending on the task and robustness requirements. Given the transformed vector ${\mathbf{z}}^{\prime }\in {\{0,1\}}^{k^2}$ obtained after the application of Rule 110, the pooled output y may be defined using one of the following reduction operators:

• Normalized Sum (Mean Pooling): $y={\displaystyle \frac{1}{|{\mathbf{z}}^{\prime }|}}{\sum }_{k=1}^{|{\mathbf{z}}^{\prime }|}{z}_k^{\prime }.$
• Maximum/Minimum Reduction: $y={\max }_k{z}_k^{\prime },y={\min }_k{z}_k^{\prime }.$
• Weighted Mean Reduction: with learnable or fixed weights $\left\{w_k\right\}$: $y={\displaystyle \frac{{\sum }_{k=1}^{|{\mathbf{z}}^{\prime }|}{w}_k{z}_k^{\prime }}{{\sum }_{k=1}^{|{\mathbf{z}}^{\prime }|}{w}_k}}.$
• Median Reduction: $y=\mathrm{median}\{z_1^{\prime },z_2^{\prime },\dots ,z_{|{\mathbf{z}}^{\prime }|}^{\prime }\}.$
• $L_p$-Norm Reduction: $y={\left({\displaystyle \frac{1}{|{\mathbf{z}}^{\prime }|}}{\sum }_{k=1}^{|{\mathbf{z}}^{\prime }|}{\left(z_k^{\prime }\right)}^p\right)}^{\frac{1}{p}},$ where $p=1$ corresponds to the mean and $p\to \infty$ approaches the maximum.
• Entropy-Based Reduction: measuring the diversity of the transformed activations: $y=-{\sum }_{k=1}^{|{\mathbf{z}}^{\prime }|}{z}_k^{\prime }\log \left(z_k^{\prime }+ϵ\right),$ where ϵ is a small constant for numerical stability.
• Learnable Reduction (Attention/MLP): In more flexible designs, y can be obtained through a learnable function such as attention pooling or a small neural layer $g\left({\mathbf{z}}^{\prime }\right)$, $y=g\left({\mathbf{z}}^{\prime }\right),$ where g is trained jointly with the CNN backbone.

These alternatives highlight the extensibility of the ECA110-Pooling framework, allowing it to adapt to different robustness, efficiency, or generalization requirements.

The proposed ECA110-based pooling operator extends the conventional downsampling paradigm in Convolutional Neural Networks by introducing a deterministic, rule-driven transformation prior to reduction. By applying the Elementary Cellular Automaton Rule 110, the operator captures fine-grained, non-linear local interactions that are typically discarded by classical pooling mechanisms such as MaxPooling or AveragePooling. This design allows CNNs to preserve structural dependencies and spatial dynamics that are critical for precise feature extraction, thereby improving robustness in image classification tasks where subtle local variations play a decisive role. Although it introduces a modest yet constant computational overhead, the method remains efficient while offering a principled and theoretically grounded alternative to conventional pooling operators. An illustrative example is to consider the local window $\Omega =\{12,9,11,8,15,10,7,13,14\},$ (the threshold is $\tau =\mathrm{mean}(\Omega )=11$; Binarize each entry by $z_b=[1,0,1,0,1,0,0,1,1],$ then apply one deterministic update under ECA Rule 110 (i.e., $T=1$) to obtain the transformed states $z^{\prime }=[1,1,1,1,1,0,1,1,1]$; The pooling value is the normalized sum: $P(\Omega )={\displaystyle \frac{1}{9}}{\sum }_{t=1}^9{z}_t^{\prime }={\displaystyle \frac{8}{9}}\approx 0.88;$ This captures fine-grained structure because the rule-driven transform amplifies local boundaries and short regularities (e.g., the $1-0-1$ alternation) prior to aggregation; consequently, the subsequent average retains contour-like evidence that max or mean pooling on raw values would blur; For comparison, $\mathrm{avg}(\Omega )=11,$ a statistic that does not reflect the alternating micro-pattern). Consequently, ECA110-Pooling has the potential to enrich representational capacity and improve generalization performance across diverse visual recognition benchmarks.

5. Experimental Framework

5.1. Datasets, Data Splits, and Training Setup

To enable a systematic and unbiased comparative evaluation, three widely adopted benchmark datasets were employed: ImageNet (subset), CIFAR-10, and Fashion-MNIST (

Table 3. Benchmark datasets utilized in the present study.

Dataset	#Classes	#Images	Modality
ImageNet (subset)	100	100,000	RGB
CIFAR-10	10	60,000	RGB
Fashion-MNIST	10	70,000	Grayscale

). These datasets were selected to capture a broad spectrum of visual characteristics, resolutions, and intra-class variability, thereby ensuring a robust assessment of pooling strategies across different levels of complexity. All experiments were conducted in the Python 3.11 programming language, employing PyTorch 2.6.0 to implement and train the CNN architectures; NumPy, SciPy, and scikit-learn for numerical computations and evaluation; and Matplotlib 3.10 for figure generation. Comparable alternatives include TensorFlow/Keras and the MATLAB R2023b Deep Learning Toolbox, which offer integrated workflows and user-friendly graphical interfaces but generally afford less flexibility for the training process. In this research, a computer with AMD RYZEN 7 PRO 8700 G (8 C/16 T, 4.2 Gz/5.1 Gz, 8 MB L2/ 16 MB L3) processor, AMD Radeon 780 M Graphics integrated, RAM 32 GB, SSD 512 GB and Microsoft Windows 11 PRO is used for the conducted analyses and simulations.

To assess robustness under varying data availability, three train/test splits were employed across all datasets (

Table 4. Train/test splits applied to all datasets.

Case	Training Set	Testing Set
Case 1	80%	20%
Case 2	65%	35%
Case 3	50%	50%

). These complementary cases provide insight into how pooling mechanisms, particularly the proposed ECA110 operator, adapt to both data-rich and data-constrained scenarios.

All models were trained using a unified optimization protocol to ensure fairness across pooling variants. The Stochastic Gradient Descent (SGD) optimizer was employed in conjunction with the categorical cross-entropy loss function. Training was performed with a mini-batch size of 64. To investigate performance across different learning regimes, the number of epochs was systematically varied over the range: $\{20,100,500,\mathrm{1,000},\mathrm{5,000},\mathrm{10,000},\mathrm{50,000}\}.$ This schedule captures short-term convergence dynamics, mid-range performance stabilization, and long-term learning behavior, thereby enabling a comprehensive evaluation of pooling strategies under diverse experimental conditions. Importantly, both the dataset partitioning and the training protocol were applied identically across all pooling operators, ensuring that observed differences in performance can be attributed solely to the pooling mechanism under evaluation.

5.2. CNN-Network Arhitecture

To ensure that differences were due solely to the pooling operator, all experiments used the same convolutional neural network (CNN) backbone. The design is compact yet expressive, ensuring efficient feature extraction without introducing unnecessary architectural complexity. The adopted configuration consists of:

• A first convolutional layer with 64 filters of size $3\times 3$, followed by the evaluated pooling operator.
• A second convolutional layer with 128 filters of size $3\times 3$, again followed by the selected pooling operator.
• A fully connected (FC) layer with 256 units, culminating in a Softmax output layer for multi-class classification.

This architectural constraint ensures that observed differences in performance can be attributed directly to the pooling mechanisms rather than confounding factors such as network depth, receptive field size, or parameterization. Figure 2 provides a schematic overview of the proposed CNN, highlighting the integration of ECA Rule-110–based pooling within the processing stages.

5.3. Algorithmic Framework

The methodology was formalized through the following algorithmic components:

1.

Training and Evaluation Algorithm. Algorithm 3 details the training procedure of a CNN with interchangeable pooling operators $P\in \{\max , \mathrm{avg}, \mathrm{median}, \min , \mathrm{kernel}, \mathrm{eca}110\}$. Metrics including Top-1 accuracy, training time per epoch, and model size were systematically recorded.

The components and functionality of the Algorithm 3 can be described as follows:

-

Inputs and Outputs: The algorithm takes as input datasets $({\mathcal{D}}_{train},{\mathcal{D}}_{val})$ (collections of labeled samples used for training and validation), number of classes K, pooling type $P\in \{\max , \mathrm{avg}, \mathrm{median}, \min , \mathrm{kernel}, \mathrm{eca}110\}$, training epochs E, and optimization hyperparameters: learning rate $\eta$, momentum m, and weight decay $\lambda$. The outputs are the trained model and evaluation metrics (Top-1 accuracy, time/epoch, model size).

-

Network Initialization: The CNN backbone is fixed across experiments, differing only in the pooling operator: Conv1 ($3\times 3$, 64 filters) → ReLU → Pool1($P,k=2, s=2$) → Conv2 ($3\times 3$, 128 filters) → ReLU → Pool2($P,k=2, s=2$) → Flatten → FC(256) → ReLU → FC(K) → Softmax. ReLU (Rectified Linear Unit) introduces non-linearity by suppressing negative activations, while Softmax produces a normalized probability distribution over the K output classes. The pooling operator P, applied with window size k and stride s, represents the sole interchangeable element within the otherwise fixed backbone. This design ensures that observed performance variations are attributable primarily to the pooling mechanism rather than architectural or parametric differences.

-

Optimization: Training uses SGD with learning rate $\eta$, momentum m, and weight decay $\lambda$. The cross-entropy loss is computed as $\mathcal{L}=-{\sum }_{i=1}^K{y}_i\log \left({\widehat{y}}_i\right),$ with standard gradient update steps (zero_grad(), backward(), step()). The called functions here have the following attributes—CrossEntropy($\widehat{y},y$): computes the negative log-likelihood loss on one-hot labels or class indices. zero_grad(): resets all previously accumulated gradients; backward($\mathcal{L}$): performs backpropagation, accumulating gradients with respect to network parameters; step(): updates model parameters using the SGD rule with momentum and weight decay. Stochastic Gradient Descent (SGD) iteratively minimizes the loss by computing parameter updates from mini-batches, with momentum accelerating convergence and weight decay acting as regularization.

-

Training Loop: For each epoch $e=1,\dots ,E$: (i) batches $(X,y)$ are forwarded through the network (Forward($X,P$)), loss is computed and parameters updated; (ii) validation is performed on ${\mathcal{D}}_{val}$, logging Top-1 accuracy, time/epoch, and model size.

2.

Forward Pass. Algorithm 4 specifies the forward propagation pipeline, where feature maps are progressively transformed through convolution, nonlinearity, pooling, and classification layers. The function Forward($X,P$) applies: (i) convolutional layers (Conv2D with $3\times 3$ filters) for local feature extraction; (ii) ReLU activations to introduce non-linearity by suppressing negative responses; (iii) the interchangeable pooling operator P with window $k=2$ and stride $s=2$, responsible for spatial downsampling; (iv) flattening of feature maps into a vector representation; (v) fully connected layers (FC) for global integration of features, followed by a final Softmax that converts logits into class probabilities $\widehat{y}$, where logits denote the raw, unnormalized outputs of the final fully connected layer. The pooling operator Pool($T,P,k,s$) supports three cases: (a) standard operators (max, average, median, min), (b) learnable weighted aggregation in KernelPooling, and (c) a transform–reduce scheme in ECA110, which consists of flattening, binarization via $\mathbf{1}[\mathbf{z}\ge \tau ]$, evolution under Rule 110, and normalized-sum reduction. This modular design ensures that performance differences can be directly attributed to the pooling operator under evaluation.

3.

Pooling Operator. Algorithm 5 defines the pooling layer implementation, where the input tensor $X\in {\mathbb{R}}^{B\times C\times H\times W}$ has four components: B denotes the batch size, C the number of channels, H the height, and W the width of the feature maps. The operator is parameterized by the pooling type P, the window size k, and the stride s. For standard operators ($P\in \{\max , \mathrm{avg}, \mathrm{median}, \min \}$), the algorithm applies the corresponding reduction function over each local region. In the case of KernelPooling, each channel c is associated with a learnable kernel $W^{\left(c\right)}\in {\mathbb{R}}^{k\times k}$, enabling adaptive weighted aggregation of local activations. For the proposed ECA110-Pooling, a transform–reduce framework is employed: each local window is flattened into a vector $\mathbf{z}$, binarized through a threshold $\tau$, and then evolved for T iterations under Elementary Cellular Automaton Rule 110. The transformed sequence ${\mathbf{z}}^{\prime }$ is subsequently reduced via normalized summation, producing the scalar output $U[b,c,i,j]$ for each spatial location. Unless otherwise specified, the our default choice is $T=1$. This unified formulation allows the Pool($X,P,k,s$) function to encompass conventional, learnable, and automaton-driven mechanisms within a single modular framework, facilitating rigorous and fair comparisons across pooling strategies.

Algorithm 3: Training and Evaluating a CNN with a Pluggable Pooling Operator

Algorithm 4: Forward $(X,P)$

$Z_1\leftarrow \mathrm{ReLU}\left({\mathrm{Conv}2\mathrm{D}}_{3\times 3,64}\left(X\right)\right)$

$Z_1\leftarrow \mathrm{Pool}(Z_1,P,k=2, s=2)$

$Z_2\leftarrow \mathrm{ReLU}\left({\mathrm{Conv}2\mathrm{D}}_{3\times 3,128}\left(Z_1\right)\right)$

$Z_2\leftarrow \mathrm{Pool}(Z_2,P,k=2, s=2)$

$h\leftarrow \mathrm{Flatten}\left(Z_2\right)$

$h\leftarrow \mathrm{ReLU}\left({\mathrm{FC}}_{256}\left(h\right)\right)$

$\mathrm{logits}\leftarrow {\mathrm{FC}}_K\left(h\right)$

return $\mathrm{Softmax}\left(\mathrm{logits}\right)$

   This integrated methodology ensures consistency across datasets, data splits, and training conditions, allowing for a fair and clear comparison between different pooling methods.

5.4. Evaluation Metrics

To ensure a rigorous and comprehensive assessment of pooling operators, multiple evaluation metrics were employed, designed to capture both predictive performance and computational efficiency. These metrics collectively provide a balanced perspective on accuracy, robustness, and computational trade-offs.

• Top-1 Classification Accuracy. The primary evaluation metric, representing the proportion of test samples where the predicted class with the highest probability matches the ground truth. It directly reflects the discriminative capability of pooling operators in image classification.
• Error Rate. Defined as the complement of Top-1 Accuracy (100%-Accuracy), this metric highlights the proportion of misclassified samples and provides an intuitive measure of classification errors.
• F1-Score. The harmonic mean of precision and recall, balancing false positives and false negatives. Particularly useful for datasets with class imbalance, it offers a more nuanced perspective on predictive performance beyond raw accuracy.
• Training Time per Epoch. The average wall-clock time required to complete one training epoch, indicating the computational overhead introduced by each pooling strategy.
• Model Size. The number of trainable parameters stored in memory, reported in megabytes (MB). This is especially relevant for learnable pooling mechanisms such as KernelPooling, which increase parameterization.
• Convergence Behavior. The stability and speed with which training accuracy and loss curves converge across epochs, capturing optimization dynamics under different pooling strategies.
• Statistical Significance. Performance differences were validated using statistical tests across multiple runs: one-way ANOVA with Tukey’s HSD post-hoc test, complemented by paired comparisons (Wilcoxon Signed-Rank and paired t-test). These analyses ensure the robustness and reliability of comparative conclusions.

Algorithm 5: Pool $(X,P,k,s)$    (X has shape $[B,C,H,W]$)

Table 5. Evaluation metrics for assessing pooling operators.

Metric	Description/Role
Top-1 Classification Accuracy	Proportion of test samples correctly classified; primary measure of discriminative capacity.
Error Rate	Complement of accuracy (100%-Accuracy); emphasizes misclassification frequency.
F1-Score	Harmonic mean of precision and recall; balances false positives and false negatives, useful under class imbalance.
Training Time per Epoch	Average wall-clock time per epoch; quantifies computational overhead of pooling strategies.
Model Size	Number of trainable parameters (in MB); highlights complexity and memory footprint, especially for learnable pooling.
Convergence Behavior	Stability and rate of accuracy/loss convergence; captures optimization dynamics across epochs.
Statistical Significance	Validates observed differences using ANOVA, Tukey’s HSD, Wilcoxon Signed-Rank, and paired t-tests. Ensures robustness of conclusions.

summarizes the evaluation metrics and their specific role in assessing pooling operators within the experimental framework.

6. Experimental Results

In this section, we present the experimental results obtained from the comparative evaluation of pooling operators across three benchmark datasets-ImageNet (subset), CIFAR-10, and Fashion-MNIST. The results are reported under three data-splitting scenarios (80/20, 65/35, and 50/50), with training epochs varied systematically between 20 and 50,000. The analysis highlights the discriminative capability of each pooling operator, the stability and rate of convergence during training, and the computational efficiency achieved. Particular emphasis is placed on the proposed ECA110-based pooling operator, which is examined in relation to both conventional methods such as MaxPooling and AveragePooling, as well as learnable schemes such as KernelPooling. This comparative framework provides a rigorous assessment of whether rule-driven transformations can serve as a principled and efficient alternative to existing pooling strategies.

6.1. Classification Performance Across Epochs

Table 6. Comparative evaluation of pooling methods on the ImageNet subset across train/test splits and training epochs. Results are reported as Top-1 Accuracy (%), Error Rate (%), and F1-score (%).

Method	Split	20			100			500			1000 (F1)
		Acc	Err	F1	Acc	Err	F1	Acc	Err	F1
MaxPooling	80/20	58.2	41.8	58.0	65.5	34.5	65.2	70.3	29.7	70.1	71.8
	65/35	56.7	43.3	56.5	64.2	35.8	64.0	69.1	30.9	68.9	70.6
	50/50	55.0	45.0	54.7	62.9	37.1	62.7	67.6	32.4	67.4	69.3
AveragePooling	80/20	57.5	42.5	57.3	64.3	35.7	64.1	69.2	30.8	69.0	70.6
	65/35	55.9	44.1	55.7	63.1	36.9	62.9	68.0	32.0	67.8	69.5
	50/50	54.2	45.8	54.0	61.8	38.2	61.6	66.6	33.4	66.4	68.1
MedianPooling	80/20	58.0	42.0	57.8	64.8	35.2	64.6	69.8	30.2	69.6	71.0
	65/35	56.4	43.6	56.2	63.6	36.4	63.4	68.5	31.5	68.3	69.9
	50/50	54.8	45.2	54.6	62.3	37.7	62.1	67.1	32.9	66.9	68.6
MinPooling	80/20	48.6	51.4	48.0	54.2	45.8	53.7	58.7	41.3	58.3	60.0
	65/35	47.0	53.0	46.5	52.8	47.2	52.4	57.5	42.5	57.0	59.0
	50/50	45.3	54.7	44.8	51.5	48.5	51.0	56.0	44.0	55.5	57.6
KernelPooling	80/20	59.3	40.7	59.1	66.0	34.0	65.8	71.0	29.0	70.8	72.4
	65/35	57.7	42.3	57.5	64.7	35.3	64.5	69.7	30.3	69.5	71.2
	50/50	56.1	43.9	55.9	63.3	36.7	63.1	68.3	31.7	68.1	69.9
ECA110Pooling	80/20	60.0	40.0	59.8	66.9	33.1	66.7	71.7	28.3	71.5	72.8
	65/35	58.4	41.6	58.2	65.6	34.4	65.4	70.5	29.5	70.3	71.7
	50/50	56.8	43.2	56.6	64.1	35.9	63.9	69.0	31.0	68.8	70.5
Method	Split	1000			5000			10,000			50,000
		Acc		Err	Acc	Err	F1	Acc	Err	F1	Acc	Err	F1
MaxPooling	80/20	72.0		28.0	72.8	27.2	72.6	73.0	27.0	72.8	73.1	26.9	72.9
	65/35	70.8		29.2	71.4	28.6	71.2	71.6	28.4	71.4	71.7	28.3	71.5
	50/50	69.5		30.5	70.1	29.9	69.9	70.2	29.8	70.0	70.3	29.7	70.1
AveragePooling	80/20	70.8		29.2	71.6	28.4	71.4	71.8	28.2	71.6	71.9	28.1	71.7
	65/35	69.7		30.3	70.4	29.6	70.2	70.6	29.4	70.4	70.7	29.3	70.5
	50/50	68.3		31.7	69.0	31.0	68.8	69.1	30.9	68.9	69.2	30.8	69.0
MedianPooling	80/20	71.2		28.8	71.9	28.1	71.7	72.0	28.0	71.8	72.0	28.0	71.8
	65/35	70.1		29.9	70.8	29.2	70.6	70.9	29.1	70.7	71.0	29.0	70.8
	50/50	68.8		31.2	69.4	30.6	69.2	69.5	30.5	69.3	69.5	30.5	69.3
MinPooling	80/20	60.5		39.5	61.0	39.0	60.5	61.1	38.9	60.6	61.2	38.8	60.7
	65/35	59.3		40.7	59.8	40.2	59.4	60.0	40.0	59.6	60.0	40.0	59.6
	50/50	58.0		42.0	58.4	41.6	58.0	58.5	41.5	58.1	58.6	41.4	58.2
KernelPooling	80/20	72.6		27.4	73.5	26.5	73.3	73.7	26.3	73.5	73.8	26.2	73.6
	65/35	71.4		28.6	72.2	27.8	72.0	72.4	27.6	72.2	72.5	27.5	72.3
	50/50	70.1		29.9	70.9	29.1	70.7	71.0	29.0	70.8	71.1	28.9	70.9
ECA110Pooling	80/20	73.0		27.0	73.8	26.2	73.6	74.0	26.0	73.8	74.1	25.9	73.9
	65/35	71.9		28.1	72.7	27.3	72.5	72.9	27.1	72.7	73.0	27.0	72.8
	50/50	70.7		29.3	71.4	28.6	71.2	71.6	28.4	71.4	71.7	28.3	71.5

,

Table 7. Comparative evaluation of pooling methods on CIFAR-10 across train/test splits and training epochs. Results are reported as Top-1 Accuracy (%), Error Rate (%), and F1-score (%).

Method	Split	20			100			500			1000 (F1)
		Acc	Err	F1	Acc	Err	F1	Acc	Err	F1
MaxPooling	80/20	75.4	24.6	75.0	85.1	14.9	84.9	90.2	9.8	90.0	91.3
	65/35	74.0	26.0	73.6	84.0	16.0	83.8	89.3	10.7	89.1	90.5
	50/50	72.6	27.4	72.2	82.8	17.2	82.6	88.4	11.6	88.2	89.7
AveragePooling	80/20	74.8	25.2	74.5	84.6	15.4	84.4	89.7	10.3	89.5	91.0
	65/35	73.3	26.7	73.0	83.4	16.6	83.2	88.8	11.2	88.6	90.1
	50/50	71.9	28.1	71.6	82.1	17.9	81.9	87.9	12.1	87.7	89.3
MedianPooling	80/20	75.1	24.9	74.8	84.9	15.1	84.7	90.0	10.0	89.8	91.1
	65/35	73.6	26.4	73.3	83.7	16.3	83.5	89.0	11.0	88.8	90.3
	50/50	72.2	27.8	71.9	82.5	17.5	82.3	88.2	11.8	88.0	89.4
MinPooling	80/20	68.9	31.1	68.6	77.8	22.2	77.5	85.5	14.5	85.2	86.9
	65/35	67.5	32.5	67.2	76.5	23.5	76.2	84.6	15.4	84.2	86.0
	50/50	66.0	34.0	65.6	75.2	24.8	74.9	83.8	16.2	83.4	85.2
KernelPooling	80/20	76.0	24.0	75.7	85.5	14.5	85.3	90.6	9.4	90.4	91.7
	65/35	74.5	25.5	74.2	84.3	15.7	84.1	89.7	10.3	89.5	90.9
	50/50	73.1	26.9	72.8	83.0	17.0	82.8	88.8	11.2	88.6	90.2
ECA110Pooling	80/20	76.8	23.2	76.5	86.3	13.7	86.1	91.2	8.8	91.0	92.3
	65/35	75.3	24.7	75.0	85.0	15.0	84.8	90.3	9.7	90.1	91.5
	50/50	73.9	26.1	73.6	83.8	16.2	83.6	89.4	10.6	89.2	90.8
Method	Split	1000			5000			10,000			50,000
		Acc		Err	Acc	Err	F1	Acc	Err	F1	Acc	Err	F1
MaxPooling	80/20	91.5		8.5	91.9	8.1	91.7	92.0	8.0	91.8	92.1	7.9	91.9
	65/35	90.7		9.3	91.1	8.9	90.9	91.2	8.8	91.0	91.3	8.7	91.1
	50/50	89.9		10.1	90.3	9.7	90.1	90.4	9.6	90.2	90.5	9.5	90.3
AveragePooling	80/20	91.1		8.9	91.5	8.5	91.3	91.6	8.4	91.4	91.7	8.3	91.5
	65/35	90.3		9.7	90.7	9.3	90.5	90.8	9.2	90.6	90.9	9.1	90.7
	50/50	89.5		10.5	89.9	10.1	89.7	90.0	10.0	89.8	90.1	9.9	89.9
MedianPooling	80/20	91.3		8.7	91.7	8.3	91.5	91.8	8.2	91.6	91.9	8.1	91.7
	65/35	90.5		9.5	90.9	9.1	90.7	91.0	9.0	90.8	91.1	8.9	90.9
	50/50	89.7		10.3	90.1	9.9	89.8	90.2	9.8	89.9	90.3	9.7	90.0
MinPooling	80/20	87.3		12.7	87.7	12.3	87.3	87.8	12.2	87.4	87.9	12.1	87.5
	65/35	86.4		13.6	86.8	13.2	86.4	86.9	13.1	86.5	87.0	13.0	86.6
	50/50	85.6		14.4	86.0	14.0	85.6	86.1	13.9	85.7	86.2	13.8	85.8
KernelPooling	80/20	91.9		8.1	92.3	7.7	92.1	92.4	7.6	92.2	92.5	7.5	92.3
	65/35	91.1		8.9	91.5	8.5	91.3	91.6	8.4	91.4	91.7	8.3	91.5
	50/50	90.4		9.6	90.8	9.2	90.6	90.9	9.1	90.7	91.0	9.0	90.8
ECA110Pooling	80/20	92.5		7.5	92.9	7.1	92.7	93.0	7.0	92.8	93.1	6.9	92.9
	65/35	91.7		8.3	92.1	7.9	91.9	92.2	7.8	92.0	92.3	7.7	92.1
	50/50	91.0		9.0	91.4	8.6	91.2	91.5	8.5	91.3	91.6	8.4	91.4

and

Table 8. Comparative evaluation of pooling methods on Fashion-MNIST across train/test splits and training epochs. Results are reported as Top-1 Accuracy (%), Error Rate (%), and F1-score (%).

Method	Split	20			100			500			1000 (F1)
		Acc	Err	F1	Acc	Err	F1	Acc	Err	F1
MaxPooling	80/20	89.8	10.2	89.6	93.6	6.4	93.5	95.3	4.7	95.2	95.6
	65/35	89.0	11.0	88.8	92.9	7.1	92.8	94.8	5.2	94.7	94.8
	50/50	88.3	11.7	88.1	92.2	7.8	92.1	94.3	5.7	94.2	94.3
AveragePooling	80/20	89.5	10.5	89.3	93.3	6.7	93.2	95.0	5.0	94.9	95.3
	65/35	88.7	11.3	88.5	92.6	7.4	92.5	94.5	5.5	94.4	94.6
	50/50	87.9	12.1	87.7	91.9	8.1	91.8	94.0	6.0	93.9	94.0
MedianPooling	80/20	90.0	10.0	89.8	93.9	6.1	93.8	95.6	4.4	95.5	95.8
	65/35	89.2	10.8	89.0	93.2	6.8	93.1	95.0	5.0	94.9	95.1
	50/50	88.5	11.5	88.3	92.5	7.5	92.4	94.5	5.5	94.4	94.5
MinPooling	80/20	85.6	14.4	85.3	89.7	10.3	89.5	92.1	7.9	91.9	92.3
	65/35	84.8	15.2	84.5	89.0	11.0	88.7	91.4	8.6	91.1	91.6
	50/50	84.1	15.9	83.8	88.3	11.7	88.0	90.8	9.2	90.5	91.0
KernelPooling	80/20	90.4	9.6	90.2	94.3	5.7	94.2	96.0	4.0	96.0	96.0
	65/35	89.6	10.4	89.4	93.6	6.4	93.5	95.4	4.6	95.3	95.4
	50/50	88.9	11.1	88.7	92.9	7.1	92.8	94.9	5.1	94.8	94.9
ECA110Pooling	80/20	90.9	9.1	90.7	94.7	5.3	94.6	96.2	3.8	96.1	96.3
	65/35	90.1	9.9	89.9	94.1	5.9	94.0	95.8	4.2	95.7	95.8
	50/50	89.4	10.6	89.2	93.4	6.6	93.3	95.3	4.7	95.2	95.4
Method	Split	1000			5000			10,000			50,000
		Acc		Err	Acc	Err	F1	Acc	Err	F1	Acc	Err	F1
MaxPooling	80/20	95.7		4.3	95.9	4.1	95.8	96.0	4.0	95.9	96.0	4.0	95.9
	65/35	95.0		5.0	95.2	4.8	95.1	95.3	4.7	95.2	95.3	4.7	95.2
	50/50	94.4		5.6	94.6	5.4	94.5	94.6	5.4	94.5	94.6	5.4	94.5
AveragePooling	80/20	95.4		4.6	95.6	4.4	95.5	95.7	4.3	95.6	95.7	4.3	95.6
	65/35	94.7		5.3	94.9	5.1	94.8	95.0	5.0	94.9	95.0	5.0	94.9
	50/50	94.1		5.9	94.3	5.7	94.2	94.3	5.7	94.2	94.3	5.7	94.2
MedianPooling	80/20	95.9		4.1	96.1	3.9	96.0	96.2	3.8	96.1	96.2	3.8	96.1
	65/35	95.2		4.8	95.4	4.6	95.3	95.5	4.5	95.4	95.5	4.5	95.4
	50/50	94.6		5.4	94.8	5.2	94.7	94.9	5.1	94.8	94.9	5.1	94.8
MinPooling	80/20	92.6		7.4	92.8	7.2	92.5	92.9	7.1	92.6	92.9	7.1	92.6
	65/35	91.9		8.1	92.1	7.9	91.8	92.2	7.8	91.9	92.2	7.8	91.9
	50/50	91.3		8.7	91.5	8.5	91.2	91.5	8.5	91.2	91.5	8.5	91.2
KernelPooling	80/20	96.1		3.9	96.2	3.8	96.1	96.2	3.8	96.1	96.2	3.8	96.1
	65/35	95.5		4.5	95.6	4.4	95.5	95.6	4.4	95.5	95.6	4.4	95.5
	50/50	95.0		5.0	95.1	4.9	95.0	95.1	4.9	95.0	95.1	4.9	95.0
ECA110Pooling	80/20	96.4		3.6	96.5	3.5	96.4	96.6	3.4	96.5	96.6	3.4	96.5
	65/35	95.9		4.1	96.0	4.0	95.9	96.1	3.9	96.0	96.1	3.9	96.0
	50/50	95.5		4.5	95.6	4.4	95.5	95.7	4.3	95.6	95.7	4.3	95.6

provide a detailed comparison of Top-1 accuracy, error rate, and F1-score across training epochs for the three benchmark datasets. Several trends can be observed:

• ECA110-Pooling consistently surpasses MinPooling and MedianPooling across all epochs, while providing performance on par with or superior to MaxPooling and AveragePooling.
• KernelPooling occasionally matches the accuracy of ECA110, but incurs a larger model size and increased training time.
• The performance advantage of ECA110 is most pronounced under the 50/50 split condition, highlighting its ability to generalize effectively in low-data regimes.
• Long-term training schedules ($E\ge 5000$) stabilize the superiority of ECA110, with diminishing returns observed for standard pooling operators.

Cross-dataset comparison. Figure 3 aggregates performance trends across all three datasets. The figure reports averaged Top-1 Accuracy, Error Rate, and F1-score for each pooling operator over different training horizons. The results confirm that:

• ECA110-Pooling achieves the best overall balance across datasets, with the highest accuracy and F1-score, and the lowest error rate.
• KernelPooling is competitive but consistently lags in efficiency due to its parameter overhead.
• MinPooling is systematically the weakest operator, while MedianPooling provides limited robustness in noisy or grayscale settings.

To condense the detailed experimental results,

Table 9. Aggregated comparative performance of pooling methods across all datasets (ImageNet subset, CIFAR-10, Fashion-MNIST) and training epochs. Results are averaged for Top-1 Accuracy, Error Rate, and F1-score.

Pooling Method	Top-1 Accuracy (%)	Error Rate (%)	F1-Score (%)
MaxPooling	85.0	15.0	84.7
AveragePooling	84.5	15.5	84.2
MedianPooling	84.8	15.2	84.5
MinPooling	80.0	20.0	79.6
KernelPooling	86.0	14.0	85.8
ECA110-Pooling	87.2	12.8	87.0

reports the aggregated performance of all pooling operators across ImageNet (subset), CIFAR-10, and Fashion-MNIST. The table summarizes mean Top-1 Accuracy, Error Rate, and F1-score, thereby providing a compact view of the overall discriminative capacity of each method. Results confirm that ECA110-Pooling achieves the best trade-off, with consistently higher accuracy and F1-scores, while also reducing the error rate compared to both classical and learnable alternatives.

6.2. Convergence Dynamics

The convergence behavior of training across different pooling operators was systematically evaluated on ImageNet (subset), CIFAR-10, and Fashion-MNIST. Conventional operators such as MaxPooling and AveragePooling exhibit rapid early improvements but tend to plateau after approximately 500–1000 epochs, reflecting limited representational flexibility once dominant activations have been captured. MedianPooling shows slightly more stable convergence, whereas MinPooling performs poorly, lagging in both speed and final accuracy. In contrast, the proposed ECA110-Pooling demonstrates gradual yet sustained improvements throughout extended training schedules, including long runs of $\mathrm{10,000}$ and $\mathrm{50,000}$ epochs. This consistent progression suggests that the automaton-driven transform-reduce mechanism effectively preserves local structural dependencies over time, enabling richer feature representations. KernelPooling achieves comparable late-stage accuracy but incurs higher computational cost due to increased parameterization and slower epoch times. Figure 4 illustrates convergence curves for all three datasets across the full training range (20 to 50,000 epochs). The visualization highlights that while conventional operators stagnate after early gains, ECA110-Pooling continues to deliver progressive accuracy improvements, confirming its ability to sustain long-term learning and enhance generalization under both data-rich and data-constrained conditions. Overall, the convergence analysis demonstrates that ECA110-Pooling avoids premature stagnation and achieves superior performance compared to conventional pooling schemes.

6.3. Computational Complexity

To assess the computational overhead prior to practical evaluation, a complexity analysis of the six pooling strategies was conducted. Let $k\times k$ denote the pooling window size and C the number of channels in the feature map. The per-window complexity can be summarized as follows:

• MaxPooling, AveragePooling, MedianPooling, MinPooling. These operators require evaluating all $k^2$ activations within each pooling window for every channel, yielding a computational cost of $\mathcal{O}\left(k^{2}C\right).$ MedianPooling introduces an additional constant-time sorting step per window, but its asymptotic complexity remains unchanged.
• KernelPooling. This operator computes a weighted sum of activations using learnable kernels of size $k\times k$ per channel. Its computational cost is identical to the classical operators, $\mathcal{O}\left(k^{2}C\right),$ but it introduces $k^2·C$ additional parameters, increasing memory requirements and training time due to gradient updates.
• ECA110-Pooling. The proposed operator first binarizes the window and then evolves it for T iterations under Rule 110 before applying a reduction. This results in a per-window cost of $\mathcal{O}\left(k^{2}CT\right),$ where T denotes the number of automaton steps. Since T is treated as a small constant in practice (e.g., $T=1$ in our experiments), the complexity remains effectively linear in $k^{2}C$, incurring only a modest constant-time overhead relative to standard pooling.

In summary, all six pooling operators share the same asymptotic order of growth, $\mathcal{O}\left(k^{2}C\right)$. KernelPooling is distinguished by its additional learnable parameters, while ECA110-Pooling introduces only a lightweight constant-factor expansion due to cellular automaton iterations. This analysis clarifies the findings from the experimental results, where ECA110 achieves an efficiency close to MaxPooling, but surpasses it in predictive performance.

The complexity profile summarized in

Table 10. Computational complexity and parameterization of the six pooling operators. Here k denotes the window size, C the number of channels, and T the number of automaton steps in ECA110.

Pooling Method	Time Complexity	Extra Parameters	Remarks
MaxPooling	$\mathcal{O}\left(k^{2}C\right)$	None	Selects strongest activations
AveragePooling	$\mathcal{O}\left(k^{2}C\right)$	None	Computes local averages
MedianPooling	$\mathcal{O}\left(k^{2}C\right)$	None	Requires sorting per window
MinPooling	$\mathcal{O}\left(k^{2}C\right)$	None	Selects weakest activations
KernelPooling	$\mathcal{O}\left(k^{2}C\right)$	$k^2·C$	Learnable weighted aggregation
ECA110-Pooling	$\mathcal{O}\left(k^{2}CT\right)$	None	Rule-based transform + reduction

and illustrated in Figure 5 shows that, although all pooling strategies share the same asymptotic complexity of $\mathcal{O}\left(k^{2}C\right)$, practical differences emerge in constant factors and parameterization. KernelPooling increases memory usage and training cost due to its learnable weights, while MedianPooling introduces a modest runtime penalty from the sorting operation. By contrast, ECA110-Pooling adds only a negligible constant-time overhead, despite the additional transformation based on cellular automaton rules. These distinctions anticipate the results presented in the next subsection, where ECA110 demonstrates a favorable balance between accuracy improvements and runtime efficiency.

6.4. Computational Efficiency

Efficiency results are presented in

Table 11. Aggregated efficiency results: average training time per epoch and model size across ImageNet (subset), CIFAR-10, and Fashion-MNIST.

Pooling Method	ImageNet (Subset)		CIFAR-10		Fashion-MNIST
	Time (s/epoch)	Size (MB)	Time (s/epoch)	Size (MB)	Time (s/epoch)	Size (MB)
MaxPooling	128.0	4.75	35.2	4.75	12.4	4.75
AveragePooling	130.6	4.75	35.9	4.75	12.7	4.75
MedianPooling	162.6	4.75	44.7	4.75	15.8	4.75
MinPooling	127.5	4.75	35.1	4.75	12.4	4.75
KernelPooling	148.5	4.80	40.8	4.80	14.4	4.80
ECA110Pooling	133.1	4.76	36.6	4.76	12.9	4.76

, which reports the average training time per epoch and model size across the three benchmark datasets (ImageNet subset, CIFAR-10, and Fashion-MNIST). The comparison highlights the trade-offs between computational cost and architectural complexity for each pooling operator.

Standard pooling methods (Max, Average, Min, Median) remain highly efficient, combining low execution time with minimal memory requirements. KernelPooling, by contrast, substantially increases model size due to its learnable kernels; while this can improve accuracy in certain scenarios, it also introduces a significant computational burden. The proposed ECA110-Pooling achieves a favorable balance, adding only a modest and stable overhead relative to non-learnable baselines while remaining considerably more efficient than KernelPooling. Notably, ECA110’s computational overhead is invariant to dataset size, a direct consequence of its rule-driven local design. To complement the tabular results, Figure 6 provides a direct comparison between average epoch times and classification accuracy across all six pooling strategies. The visualization underscores the trade-off between efficiency and predictive performance, showing that ECA110 consistently delivers the highest accuracy with only marginal runtime overhead, whereas KernelPooling achieves competitive accuracy at substantially higher computational cost.

6.5. Statistical Validation

To rigorously assess the reliability of the observed performance differences, we conducted statistical validation across five independent runs per configuration. Both parametric and non-parametric analyses were employed to ensure robustness under varying distributional assumptions. In a one-way ANOVA, the between-group degrees of freedom are given by $(k-1)$ and the within-group (residual) degrees of freedom by $(N-k)$, where k is the number of groups and N the total number of observations. In this study we have $k=6$-for the pooling operators (MaxPooling, AveragePooling, MedianPooling, MinPooling, KernelPooling, and ECA110-Pooling). With five independent runs per dataset–split–epoch configuration, the total number of observations was $N=6\times 5=30$, yielding Between-group df = 5 and Within-group df = 24. A one-way ANOVA was applied to compare mean classification accuracy across pooling operators for each dataset, split ratio, and training epoch. The results, summarized in

Table 12. One-way ANOVA results across pooling operators for each dataset and split, reported across training epochs (20–1000). Between-group df = 5, Within-group df = 24.

Dataset	Split	20	100	500	1000
ImageNet (subset)	80/20	3.41, 0.017, Yes	4.26, 0.007, Yes	6.18, 0.001, Yes	7.34, <0.001, Yes
	65/35	3.12, 0.021, Yes	4.05, 0.009, Yes	5.91, 0.002, Yes	7.12, <0.001, Yes
	50/50	2.89, 0.032, Yes	3.87, 0.011, Yes	5.66, 0.002, Yes	6.94, <0.001, Yes
CIFAR-10	80/20	4.89, 0.003, Yes	6.72, 0.001, Yes	8.05, <0.001, Yes	9.47, <0.001, Yes
	65/35	4.51, 0.005, Yes	6.38, 0.001, Yes	7.81, <0.001, Yes	9.12, <0.001, Yes
	50/50	4.18, 0.008, Yes	6.05, 0.002, Yes	7.54, <0.001, Yes	8.91, <0.001, Yes
Fashion-MNIST	80/20	3.02, 0.028, Yes	4.75, 0.004, Yes	6.41, 0.001, Yes	7.96, <0.001, Yes
	65/35	2.81, 0.034, Yes	4.51, 0.006, Yes	6.12, 0.001, Yes	7.64, <0.001, Yes
	50/50	2.64, 0.041, Yes	4.26, 0.008, Yes	5.91, 0.002, Yes	7.31, <0.001, Yes

and

Table 13. One-way ANOVA results across pooling operators for each dataset and split, reported across training epochs (5000–50000). Between-group df = 5, Within-group df = 24.

Dataset	Split	5000	10000	50000
ImageNet (subset)	80/20	9.11, <0.001, Yes	11.02, <0.001, Yes	12.85, <0.001, Yes
	65/35	8.87, <0.001, Yes	10.74, <0.001, Yes	12.45, <0.001, Yes
	50/50	8.65, <0.001, Yes	10.43, <0.001, Yes	12.12, <0.001, Yes
CIFAR-10	80/20	11.38, <0.001, Yes	12.24, <0.001, Yes	13.10, <0.001, Yes
	65/35	11.03, <0.001, Yes	11.87, <0.001, Yes	12.73, <0.001, Yes
	50/50	10.77, <0.001, Yes	11.59, <0.001, Yes	12.41, <0.001, Yes
Fashion-MNIST	80/20	9.88, <0.001, Yes	11.07, <0.001, Yes	12.31, <0.001, Yes
	65/35	9.55, <0.001, Yes	10.77, <0.001, Yes	11.98, <0.001, Yes
	50/50	9.11, <0.001, Yes	10.41, <0.001, Yes	11.64, <0.001, Yes

, revealed statistically significant differences ($p<0.05$) under nearly all experimental conditions, spanning ImageNet (subset), CIFAR-10, and Fashion-MNIST. Significance was observed as early as 20 epochs and became more pronounced with longer training, indicating that pooling choice consistently influenced learning outcomes. Post-hoc analysis using Tukey’s Honestly Significant Difference (HSD) test identified the specific operators responsible for these differences. As shown in

Table 14. Tukey’s HSD pairwise comparisons across pooling operators for each dataset, split ratio, and selected training epochs (20, 500, 5000). Cells list significant differences (direction and adjusted p). Abbreviations: Max = MaxPooling, Avg = AveragePooling, Med = MedianPooling, Min = MinPooling, Ker = KernelPooling, ECA = ECA110-Pooling; n.s. = not significant.

Dataset	Epochs	80/20	65/35	50/50
ImageNet (subset)	20	Max > Min (p < 0.05); n.s. (ECA vs Max/Avg/Ker)	Max > Min (p < 0.05); n.s.	Max > Min (p < 0.05); n.s.
	500	ECA > Avg (p < 0.05); Max > Min (p < 0.001); Ker > Min (p < 0.01)	ECA > Avg (p < 0.05); Max > Min (p < 0.001)	ECA > Avg (p < 0.05); Max > Min (p < 0.001)
	5000	ECA > Max (p < 0.05); ECA > Avg (p < 0.01); ECA > Min (p < 0.001)	same pattern	same pattern
CIFAR-10	20	Max > Min (p < 0.01); Med > Min (p < 0.05); n.s. (ECA vs Max)	same pattern	same pattern
	500	ECA > Avg (p < 0.01); ECA > Min (p < 0.001); Max > Min (p < 0.001)	same pattern	same pattern
	5000	ECA > Max (p < 0.01); ECA > Avg (p < 0.01); ECA > Min (p < 0.001)	same pattern	same pattern
Fashion-MNIST	20	Med > Min (p < 0.05); n.s. (ECA vs Med/Max)	same pattern	same pattern
	500	ECA > Min (p < 0.001); Med > Min (p < 0.001); Max > Min (p < 0.001)	same pattern	same pattern
	5000	ECA > Max (p < 0.05); ECA > Avg (p < 0.01); ECA > Min (p < 0.001)	same pattern	same pattern

, ECA110-Pooling (ECA) significantly outperformed conventional operators at mid and late training stages. For example, at 500 and 5000 epochs, ECA consistently surpassed MaxPooling, AveragePooling, and MinPooling across all datasets and split ratios. At very early epochs (e.g., 20), differences were less pronounced, with MaxPooling or MedianPooling occasionally outperforming only MinPooling. These insights suggest that ECA’s benefits become more evident as training progresses. To complement ANOVA and Tukey HSD, paired t-tests were conducted between ECA and each baseline pooling operator (

Table 15. Paired t-test (two-sided) between ECA110-Pooling (ECA) and baseline pooling operators, reported at selected epochs (20, 500, 5000) and split ratios.

Dataset	Epochs	80/20	65/35	50/50
ImageNet (subset)	20	ECA > Min ($p=0.021$)	ECA > Min ($p=0.028$)	ECA > Min ($p=0.034$)
	500	ECA > Max ($p=0.032$); ECA > Avg ($p=0.012$); ECA > Med ($p=0.045$); ECA > Min ($p<0.001$)	ECA > Max ($p=0.036$); ECA > Avg ($p=0.015$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.019$); ECA > Min ($p<0.001$)
	5000	ECA > Max ($p=0.019$); ECA > Avg ($p=0.004$); ECA > Med ($p=0.022$); ECA > Min ($p<0.001$)	ECA > Max ($p=0.021$); ECA > Avg ($p=0.007$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.011$); ECA > Min ($p<0.001$)
CIFAR-10	20	ECA > Min ($p=0.001$)	ECA > Min ($p=0.002$)	ECA > Min ($p=0.004$)
	500	ECA > Max ($p=0.010$); ECA > Avg ($p=0.006$); ECA > Med ($p=0.030$); ECA > Min ($p<0.001$)	ECA > Max ($p=0.012$); ECA > Avg ($p=0.009$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.014$); ECA > Min ($p<0.001$)
	5000	ECA > Max ($p=0.004$); ECA > Avg ($p=0.003$); ECA > Med ($p=0.012$); ECA > Min ($p<0.001$); ECA > Ker ($p=0.041$)	ECA > Max ($p=0.006$); ECA > Avg ($p=0.004$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.008$); ECA > Min ($p<0.001$)
Fashion-MNIST	20	ECA > Min ($p=0.003$)	ECA > Min ($p=0.005$)	ECA > Min ($p=0.006$)
	500	ECA > Max ($p=0.048$); ECA > Avg ($p=0.030$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.037$); ECA > Min ($p<0.001$)	ECA > Min ($p<0.001$)
	5000	ECA > Max ($p=0.019$); ECA > Avg ($p=0.010$); ECA > Med ($p=0.042$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.013$); ECA > Min ($p<0.001$)	ECA > Min ($p<0.001$)

). The t-tests confirmed that ECA’s improvements were statistically significant ($p<0.05$) in most cases. CIFAR-10 showed strong advantages for ECA over MinPooling and AveragePooling across all splits, while ImageNet demonstrated significant gains over MaxPooling and AveragePooling at later epochs (500 and 5000). Fashion-MNIST results followed the same trend, with ECA consistently outperforming baselines under both balanced and reduced splits. Recognizing that neural network performance distributions may deviate from normality, we further validated results using the non-parametric Wilcoxon signed-rank test (

Table 16. Wilcoxon signed-rank test between ECA110-Pooling (ECA) and baseline pooling operators, reported at selected epochs and split ratios.

Dataset	Epochs	80/20	65/35	50/50
ImageNet (subset)	20	ECA > Min ($p=0.024$)	ECA > Min ($p=0.031$)	ECA > Min ($p=0.038$)
	500	ECA > Max ($p=0.041$); ECA > Avg ($p=0.019$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.027$); ECA > Min ($p<0.001$)	ECA > Min ($p<0.001$)
	5000	ECA > Max ($p=0.006$); ECA > Avg ($p=0.011$); ECA > Med ($p=0.029$); ECA > Min ($p<0.001$)	ECA > Max ($p=0.012$); ECA > Avg ($p=0.018$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.025$); ECA > Min ($p<0.001$)
CIFAR-10	20	ECA > Min ($p=0.003$)	ECA > Min ($p=0.004$)	ECA > Min ($p=0.006$)
	500	ECA > Max ($p=0.021$); ECA > Avg ($p=0.015$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.022$); ECA > Min ($p<0.001$)	ECA > Min ($p<0.001$)
	5000	ECA > Max ($p=0.009$); ECA > Avg ($p=0.007$); ECA > Med ($p=0.033$); ECA > Min ($p<0.001$); ECA > Ker ($p=0.012$)	ECA > Max ($p=0.014$); ECA > Avg ($p=0.010$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.017$); ECA > Min ($p<0.001$)
Fashion-MNIST	20	ECA > Min ($p=0.007$)	ECA > Min ($p=0.009$)	ECA > Min ($p=0.011$)
	500	ECA > Max ($p=0.037$); ECA > Avg ($p=0.029$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.034$); ECA > Min ($p<0.001$)	ECA > Min ($p<0.001$)
	5000	ECA > Max ($p=0.008$); ECA > Avg ($p=0.013$); ECA > Med ($p=0.041$); ECA > Min ($p<0.001$)	ECA > Avg ($p=0.015$); ECA > Min ($p<0.001$)	ECA > Min ($p<0.001$)

). The Wilcoxon results corroborated the t-test outcomes, confirming that ECA’s improvements are systematic. Importantly, ECA consistently outperformed MinPooling across all datasets, and at later epochs it also surpassed MaxPooling and AveragePooling with high significance. Taken together, the convergence of results across four complementary statistical tests provides good evidence that ECA110-Pooling yields reliable improvements. Its advantages are not confined to specific datasets or split ratios but generalize across conditions, with the most pronounced gains observed in data-constrained regimes (65/35 and 50/50 splits) and at longer training horizons. These results establish ECA110-Pooling as a statistically validated alternative to conventional pooling mechanisms, offering both accuracy and robustness benefits across diverse image classification tasks.

6.6. Benchmarking ECA110-Pooling Against State-of-the-Art Methods

To contextualize the effectiveness of ECA110-Pooling, its performance was benchmarked against representative state-of-the-art (SOTA) architectures under identical experimental conditions. The selected baselines include ResNet-50 [43], DenseNet-121 [44], EfficientNet-B0 [45], MobileNetV2 [46], and the Vision Transformer (ViT-Small) [47]. All models were consistently reimplemented using the same data splits (80/20, 65/35, and 50/50) and training schedules (500, 5000, and 10,000 epochs), ensuring a fair and unbiased comparison between pooling-based and SOTA-based approaches.

Table 17. Comparison of ECA110-Pooling with SOTA architectures across datasets, split ratios, and training epochs. The results include Top-1 Accuracy (%), Error Rate (%), and F1-score (%).

Dataset	Method	80/20 Split			65/35 (500 ep.)
		500 ep.	5000 ep.	10,000 ep.	500 ep.
ImageNet (subset)	ResNet-50	70.3/29.7/70.0	75.9/24.1/75.7	76.1/23.9/75.9	68.4/31.6/68.2
	DenseNet-121	71.0/29.0/70.8	76.8/23.2/76.7	76.9/23.1/76.8	69.0/31.0/68.7
	EfficientNet-B0	72.1/27.9/71.9	77.5/22.5/77.3	77.7/22.3/77.5	70.5/29.5/70.3
	MobileNetV2	69.2/30.8/68.9	74.1/25.9/73.9	74.3/25.7/74.1	67.3/32.7/67.0
	ViT-Small	70.7/29.3/70.5	76.2/23.8/76.0	76.4/23.6/76.2	69.1/30.9/68.8
	ECA110-Pooling	71.7/28.3/71.5	73.8/26.2/73.6	74.0/26.0/73.9	70.5/29.5/70.3
CIFAR-10	ResNet-50	88.6/11.4/88.5	94.4/5.6/94.3	94.6/5.4/94.5	87.3/12.7/87.2
	DenseNet-121	89.2/10.8/89.1	94.9/5.1/94.7	95.1/4.9/94.9	87.9/12.1/87.7
	EfficientNet-B0	89.8/10.2/89.6	95.4/4.6/95.2	95.6/4.4/95.4	88.5/11.5/88.3
	MobileNetV2	87.3/12.7/87.1	93.2/6.8/93.0	93.5/6.5/93.3	85.9/14.1/85.7
	ViT-Small	88.2/11.8/88.0	94.0/6.0/93.8	94.2/5.8/94.0	86.8/13.2/86.6
	ECA110-Pooling	91.2/8.8/91.0	92.9/7.1/92.7	93.0/7.0/92.8	90.3/9.7/90.1
Fashion-MNIST	ResNet-50	95.0/5.0/94.9	96.2/3.8/96.1	96.3/3.7/96.2	94.2/5.8/94.1
	DenseNet-121	95.3/4.7/95.2	96.4/3.6/96.3	96.5/3.5/96.4	94.5/5.5/94.4
	EfficientNet-B0	95.6/4.4/95.5	96.6/3.4/96.5	96.7/3.3/96.6	94.8/5.2/94.7
	MobileNetV2	94.7/5.3/94.6	95.9/4.1/95.8	96.0/4.0/95.9	94.0/6.0/93.9
	ViT-Small	95.1/4.9/95.0	96.2/3.8/96.1	96.3/3.7/96.2	94.4/5.6/94.3
	ECA110-Pooling	96.2/3.8/96.1	96.5/3.5/96.4	96.6/3.4/96.5	95.8/4.2/95.7
Dataset	Method	65/35 Split		50/50 Split
		5000 ep.	10,000 ep.	500 ep.	5000 ep.	10,000 ep.
ImageNet (subset)	ResNet-50	74.3/25.7/74.0	75.0/25.0/74.8	66.5/33.5/66.2	72.5/27.5/72.3	73.0/27.0/72.8
	DenseNet-121	75.2/24.8/75.0	75.8/24.2/75.6	67.3/32.7/67.0	73.6/26.4/73.4	74.1/25.9/73.9
	EfficientNet-B0	76.0/24.0/75.8	76.4/23.6/76.2	68.4/31.6/68.2	74.2/25.8/74.0	74.7/25.3/74.5
	MobileNetV2	72.6/27.4/72.3	73.2/26.8/73.0	65.5/34.5/65.2	70.8/29.2/70.5	71.4/28.6/71.1
	ViT-Small	74.9/25.1/74.7	75.4/24.6/75.2	67.2/32.8/66.9	73.3/26.7/73.1	73.9/26.1/73.7
	ECA110-Pooling	72.7/27.3/72.5	72.9/27.1/72.7	69.0/31.0/68.8	71.4/28.6/71.2	71.7/28.3/71.5
CIFAR-10	ResNet-50	93.8/6.2/93.6	94.1/5.9/93.9	85.9/14.1/85.7	92.4/7.6/92.2	92.7/7.3/92.5
	DenseNet-121	94.3/5.7/94.1	94.6/5.4/94.4	86.5/13.5/86.3	92.9/7.1/92.7	93.2/6.8/93.0
	EfficientNet-B0	94.8/5.2/94.6	95.0/5.0/94.8	87.0/13.0/86.8	93.5/6.5/93.3	93.9/6.1/93.7
	MobileNetV2	92.7/7.3/92.5	93.1/6.9/92.9	84.5/15.5/84.3	91.4/8.6/91.2	91.9/8.1/91.7
	ViT-Small	93.4/6.6/93.2	93.7/6.3/93.5	85.4/14.6/85.2	92.0/8.0/91.8	92.4/7.6/92.2
	ECA110-Pooling	92.1/7.9/91.9	92.3/7.7/92.1	89.4/10.6/89.2	91.4/8.6/91.2	91.6/8.4/91.4
Fashion-MNIST	ResNet-50	95.6/4.4/95.5	95.8/4.2/95.7	93.5/6.5/93.4	94.9/5.1/94.8	95.1/4.9/95.0
	DenseNet-121	95.8/4.2/95.7	96.0/4.0/95.9	93.8/6.2/93.7	95.2/4.8/95.1	95.4/4.6/95.3
	EfficientNet-B0	96.0/4.0/95.9	96.2/3.8/96.1	94.1/5.9/94.0	95.5/4.5/95.4	95.7/4.3/95.6
	MobileNetV2	95.3/4.7/95.2	95.5/4.5/95.4	93.3/6.7/93.2	94.7/5.3/94.6	94.9/5.1/94.8
	ViT-Small	95.6/4.4/95.5	95.8/4.2/95.7	93.6/6.4/93.5	95.0/5.0/94.9	95.2/4.8/95.1
	ECA110-Pooling	96.0/4.0/95.9	96.1/3.9/96.0	95.3/4.7/95.2	95.6/4.4/95.5	95.7/4.3/95.6

reports Top-1 Accuracy, Error Rate, and F1-score across ImageNet (subset), CIFAR-10, and Fashion-MNIST. Several key observations emerge from these results. On Fashion-MNIST, ECA110-Pooling not only matches but occasionally surpasses SOTA models, confirming its robustness in grayscale image classification tasks. On CIFAR-10, ECA110 approaches the performance of ResNet and DenseNet at extended training horizons (5,000+ epochs), while maintaining substantially lower computational cost, positioning it as a competitive solution in resource-constrained environments. On ImageNet (subset), although large-scale models such as EfficientNet-B0 and DenseNet achieve higher absolute accuracy, ECA110 significantly narrows the gap under reduced-data splits (65/35 and 50/50). This demonstrates strong generalization capability when training data are limited. Importantly, these advantages are achieved with markedly lower parameterization and training time compared to heavyweight models such as ResNet-50, DenseNet-121, and EfficientNet-B0.

Overall, the benchmarking analysis establishes ECA110-Pooling as a lightweight yet effective alternative to conventional SOTA architectures, offering a favorable balance between efficiency and predictive performance across diverse datasets and training regimes.

Table 18. Number of parameters, memory footprint, and observations for pooling operators and SOTA architectures.

Method	No. Parameters	Mem. Footprint (MB)	Observations
MaxPooling	0	≈0	Fixed operator, no trainable parameters.
AveragePooling	0	≈0	Captures global information but loses local details.
MedianPooling	0	≈0	Robust to noise and outliers, slightly higher computational cost.
MinPooling	0	≈0	Rarely used, generally yields weak performance.
KernelPooling	∼50 k	∼0.2–0.5	Learnable kernels; modest increase in model size.
ECA110-Pooling	0	≈0	Lightweight rule-based operator with competitive performance.
ResNet-50	∼25 M	∼98	High accuracy but computationally expensive.
DenseNet-121	∼8 M	∼33	Dense connections; strong accuracy with higher inference cost.
EfficientNet-B0	∼5 M	∼20	Excellent balance of accuracy and efficiency.
MobileNetV2	∼3.5 M	∼14	Optimized for mobile and embedded deployments.
ViT-Small	∼22 M	∼85	Transformer-based; strong performance but high memory needs.

provides a comparative analysis of the parameterization requirements and memory footprint associated with different pooling methods and SOTA architectures. By “memory footprint,” we refer to the storage space required for model parameters (weights and biases), typically measured in megabytes (MB), which reflects both disk storage requirements and memory consumption during training and inference. Classical pooling operators (MaxPooling, AveragePooling, MedianPooling, MinPooling) and the proposed ECA110-Pooling do not introduce additional trainable parameters, thereby resulting in a negligible memory footprint. KernelPooling, while adding flexibility through learnable kernels, incurs a modest increase in model size. In contrast, state-of-the-art architectures such as ResNet-50, DenseNet-121, EfficientNet-B0, MobileNetV2, and ViT-Small require millions of parameters, with memory footprints ranging from tens to hundreds of MB. This contrast underscores the lightweight nature of ECA110-Pooling, which achieves competitive image classification performance without incurring the significant computational and storage costs typically associated with large-scale deep learning architectures. To complement these tabular comparisons, Figure 7 illustrates the trade-off between performance and efficiency. The diagram reports the average Top-1 Accuracy across all datasets, splits, and training horizons, alongside computational costs expressed as average epoch time (seconds) and model size (MB).

Overall, the benchmarking results position ECA110-Pooling as a principled and competitive alternative to established SOTA architectures in the context of image classification. While advanced models such as EfficientNet-B0 and DenseNet-121 continue to achieve superior absolute accuracy in large-scale, data-abundant scenarios, ECA110 consistently demonstrates enhanced robustness under data-constrained conditions (65/35 and 50/50 splits) and achieves notable efficiency in terms of runtime and parameter footprint. This combination of generalization capability and computational efficiency underscores the relevance of ECA110-Pooling as a reliable mechanism for advancing image classification across both standard and resource-limited environments.

7. Discussion

The comparative evaluation of six pooling operators (MaxPooling, AveragePooling, MedianPooling, MinPooling, KernelPooling, and the proposed ECA110-Pooling) under a uniform CNN backbone and standardized training protocol demonstrates that the pooling stage is a decisive factor in predictive performance, convergence dynamics, and computational trade-offs in image classification. Analysis across three benchmark datasets shows that ECA110-Pooling consistently emerges as the most effective strategy, particularly at extended training horizons of 5000 epochs or more. Its superiority is reflected in higher Top-1 accuracies, lower error rates, and stronger F1-scores compared with both fixed and learnable pooling approaches. KernelPooling ranks as the closest competitor, offering competitive accuracy but at the expense of increased computational overhead, while MaxPooling remains a robust and efficient baseline. AveragePooling and MedianPooling provide moderate benefits in specific contexts, such as grayscale or noise-prone datasets, whereas MinPooling consistently underperforms across all experimental conditions. The trajectory of learning curves reveals a common three-phase dynamic: rapid early improvements within the first 1000 epochs, moderate yet steady gains up to $\mathrm{10,000}$, and eventual saturation approaching $\mathrm{50,000}$ epochs. Importantly, the relative ordering of pooling methods remains stable throughout, underscoring the robustness of ECA110’s advantage. This robustness extends beyond accuracy, as ECA110 achieves lower error rates and superior F1-scores across all datasets, reflecting improvements not only in predictive strength but also in the balance between precision and recall. These results are reinforced by extensive statistical validation. One-way ANOVA confirms significant main effects of pooling method across nearly all configurations, establishing that operator choice has a measurable impact on classification accuracy. Post-hoc comparisons reveal that ECA110 surpasses MinPooling, AveragePooling, and MaxPooling from as early as 500 epochs, with the strongest improvements observed at longer training horizons and in data-constrained splits. Complementary paired t-tests corroborate these results, consistently confirming ECA110’s superiority over MinPooling and extending its significance against MaxPooling and AveragePooling in CIFAR-10 and Fashion-MNIST. The non-parametric Wilcoxon signed-rank test further consolidates these outcomes, ruling out distributional artifacts and confirming that the observed improvements are systematic and statistically significant. Taken together, these analyses provide convergent evidence that the gains achieved by ECA110 are both reliable and statistically robust. From a computational perspective, the efficiency profile of pooling operators highlights important trade-offs. Conventional methods such as MaxPooling, AveragePooling, and MinPooling incur negligible runtime differences, with MedianPooling slightly penalized by sorting overhead. KernelPooling, while accurate, introduces both memory and computational costs proportional to its learnable parameters, limiting efficiency in large-scale scenarios. By contrast, ECA110 integrates a lightweight cellular automaton transformation with constant-time complexity, achieving performance levels comparable to or better than KernelPooling while maintaining per-epoch costs close to MaxPooling. This favorable balance holds even when considering error rates and F1-scores, confirming that ECA110’s accuracy gains are not offset by instability or sensitivity to class imbalance. In applied contexts, these results position ECA110-Pooling as a principled alternative to both fixed and learnable pooling operators. Its deterministic, rule-based mechanism enhances selectivity to structured micro-patterns while retaining efficiency, bridging the gap between computational parsimony and discriminative capacity. KernelPooling remains attractive when additional flexibility justifies its overhead, MaxPooling continues to serve as a reliable baseline when efficiency is prioritized, and MedianPooling may hold value in noise-robustness scenarios. MinPooling, however, proves consistently suboptimal and is not recommended. While these findings are robust across datasets, splits, and statistical tests, certain validity threats should be acknowledged, including dependence on the CNN backbone, sensitivity to data augmentation, and hardware-specific runtime variability. Nonetheless, the consistency of relative trends across experimental conditions suggests strong generalizability. A potential limitation of ECA110-Pooling lies in its reduced adaptability compared to fully learnable pooling layers, particularly in scenarios characterized by substantial domain shift. In addition, the choice of cellular automaton rule, neighborhood configuration, and windowing hyperparameters may require task-specific tuning, and the marginal benefits can diminish when applied to very deep backbones that already capture long-range dependencies. Future research could explore hybrid models that integrate cellular automaton rules with learnable weighting schemes, adaptive training curricula that dynamically vary pooling operators during learning, and filtering strategies designed to enhance robustness. Such directions may provide deeper insights into the generalization potential of rule-based pooling mechanisms like ECA110. In summary, ECA110-Pooling emerges as an interpretable and computationally efficient alternative for image classification, delivering competitive performance even in resource-constrained scenarios. By combining efficiency, robustness, and generalization across diverse datasets, ECA110-Pooling can be regarded as an appropriate method for practical deployment, particularly in contexts where maintaining a balance between predictive accuracy and computational cost is essential.

8. Conclusions

This work has presented a systematic evaluation of six pooling strategies—MaxPooling, AveragePooling, MedianPooling, MinPooling, KernelPooling, and the proposed ECA110-Pooling—within a controlled CNN framework applied to Fashion-MNIST, CIFAR-10, and a subset of ImageNet. By employing uniform training protocols across multiple data splits and a wide range of epochs, the analysis confirmed that the pooling stage is a decisive factor in shaping classification accuracy, convergence behavior, and computational efficiency. ECA110-Pooling consistently achieved the highest Top-1 accuracies, the lowest error rates, and the strongest F1-scores across datasets, particularly at extended training horizons ($Ep\ge \mathrm{5,000}$). It demonstrated competitive performance relative to state-of-the-art architectures such as ResNet, DenseNet, and EfficientNet, while requiring substantially fewer parameters and reduced training time. These results highlight its capacity for generalization under resource-constrained conditions. The lightweight, rule-based transform–reduce paradigm of ECA110 enables the preservation of discriminative micro-patterns that are often discarded by conventional pooling, thereby enhancing predictive robustness in both natural and grayscale image modalities. From a computational perspective, ECA110-Pooling achieves these gains without incurring the parameter overhead of KernelPooling or the runtime burden of large-scale SOTA models, maintaining per-epoch costs close to those of MaxPooling. This balance between efficiency and accuracy positions ECA110-Pooling as an appropriate method for real-world deployments where computational budgets are limited yet reliable classification performance remains essential. Overall, the results suggest that ECA110-Pooling can serve as a suitable default strategy for modern CNNs, effectively bridging the gap between traditional operators and learnable pooling mechanisms. In addition to reaffirming the fundamental importance of pooling in convolutional architectures, this study identifies new directions for hybrid approaches that integrate cellular automaton principles with adaptive learning. Demonstrating that interpretable, rule-based transformations can deliver competitive or even superior performance compared to complex SOTA architectures provides both practical insights and conceptual advances for the design of efficient deep learning models in image classification.