Designing Concise ConvNets with Columnar Stages

## Abstract

Abstract In the era of vision Transformers, the recent success of VanillaNet shows the huge potential of simple and concise convolutional neural networks (ConvNets). Where such models mainly focus on runtime, it is also crucial to simultaneously focus on other aspects, e.g., FLOPs, parameters, etc, to strengthen their utility further. To this end, we introduce a refreshing ConvNet macro design called Co lumnar S tage Net work (CoSNet). CoSNet has a systematically developed simple and concise structure, smaller depth, low parameter count, low FLOPs, and attention-less operations, well suited for resource-constrained deployment. The key novelty of CoSNet is deploying parallel convolutions with fewer kernels fed by input replication, using columnar stacking of these convolutions, and minimizing the use of 1 × 1 1 1 1\times 1 1 × 1 convolution layers. Our comprehensive evaluations show that CoSNet rivals many renowned ConvNets and Transformer designs under resource-constrained scenarios. Code: https://github.com/ashishkumar822/CoSNet .

## 1 Introduction

In the past decade, there has been enormous study in the neural network architectures Krizhevsky et al. (); Simonyan & Zisserman (), demonstrating that different information paths He et al. (); Huang et al. (); Szegedy et al. (); Tan & Le (); Xie et al. () can affect the performance. However, as highlighted in recent VanillaNet Chen et al. (), due to the increased network complexity, the primary source of runtime bottleneck would be the off-chip memory traffic apart from the main computations because GPUs are constantly becoming more powerful.

The issue is prevalent in more advanced models, such as ConvNext Liu et al. (), CoatNet Dai et al. (), ViT Dosovitskiy et al. (), etc., due to the indirect information paths or the attention mechanism that requires frequent memory reordering. Hence, despite these models being far ahead of their simpler counterparts He et al. (); Krizhevsky et al. (), there are still opportunities to develop concise models for better accuracy, runtime, and resource tradeoffs.

Efforts in this direction are noteworthy. For example, RepVGG Ding et al. () improves runtime via structural parameterization. ParNet Goyal et al. () reduces depth by utilizing multiple shallower network modules. Recent VanillaNet Chen et al. () merges layers during inference while avoiding branches. These works fall in the paradigm of simplifying ConvNet models for resource-constrained scenarios, in contrast to the advanced ConvNets Dai et al. (); Liu et al. (), or ViT Dosovitskiy et al. () focusing on state-of-the-art accuracy.

We are inspired by the utility of the former class of works, i.e., simpler and concise models. However, besides focusing on runtime or depth Chen et al. (); Ding et al. (); Goyal et al. (), we also focus on other ConvNet aspects, such as FLOPs, parameters, depth, computational density, etc.
To this end, we propose a concise model by revisiting the fundamentals of prominent ConvNet designs and define the following key sub-objectives:

$1)$ Reducing depth: Network depth refers to the number of layers stacked. More depth means more sequential operations, thus more latency and wastage of parallel computing elements (GPU cores).
$2)$ Controlled parameter growth: Reducing depth to achieve lower latency leads to an increased number of parameters Chen et al. (); Goyal et al. (), thus necessitating parameter control while having short depth.
$3)$ Low branching: Network branching increases memory requirements to hold intermediate tensors and also increases memory access cost to account for the branched operations.
$4)$ High computational density: A layer must have a high computing density since fewer computations per layer waste the parallel computing cores, e.g., depthwise convolutions Howard et al. () have less computation density and high memory access cost compared to the dense convolutions Simonyan & Zisserman ().
$5)$ Uniform primitive operations: Maintaining a uniform convolution kernel size throughout the network and branches is desirable so that computations can be packed into minimum GPU transactions.

This leads to a concise refreshing ConvNet design (Figure 2) that shows enhanced performance in various aspects, such as low memory consumption, low memory access costs on parallel computing hardware, smaller depth, minimum branching, lower latency, low parameter count, and reduced FLOPs. The key attributes of CoSNet-unit are parallel columnar convolutions (Sec. 3.2), input replication (Sec. 3.3), and shallow-deep projections (Sec. 3.7), allowing CoSNet to perform better than simple ConvNets or rival the advanced designs. The achievements of CoSNet emphasize simplicity’s importance in effective ConvNet designs.

## 2 Related Work

Figure: (a)
Refer to caption: x1.png

This section provides an overview of representative network designs (Figure 1). The earlier ConvNets Krizhevsky et al. (); Simonyan & Zisserman () stacked dense convolutions with an increasing number of channels and decreasing resolution (Figure 1a). Improved versions He et al. (); Szegedy et al. (); Xie et al. () achieve higher accuracy via manually designed blocks (Figure 1c), while Howard et al. (); Ma et al. (); Sandler et al. (); Zhang et al. (), use depthwise convolutions for saving computations.

ConvNets have also grown from branchless Krizhevsky et al. (); Simonyan & Zisserman () (Figure 1a) to single branch He et al. () (Figure 1c) to multi-branch Radosavovic et al. (); Szegedy et al. (); Tan & Le (); Zoph et al. () (Figure 1b). These models utilize $1\times 1$ convolutions frequently, which rapidly increases network depth He et al. (); Sandler et al. (); Tan & Le (); Zhang et al. () (Figure 1c-1e). Although beneficial, both large depth and high branching tend to increase the latency, memory requirements, and Memory Access Cost (MAC) Chen et al. () due to the serialized execution of parallel branches Ding et al. (); Srivastava et al. (); Tan & Le ().

Recent RepVGG Ding et al. () proposes structural parameterization (SR) to resolve the branching issue. While ParNet Goyal et al. () and VanillaNet Chen et al. () reduce depth to achieve lower latency. Efforts to reduce depth increase the parameter count Chen et al. (); Goyal et al. () to match the accuracy of relatively deeper counterparts He et al. ().

Recent Vision Transformers (ViTs) Dosovitskiy et al. (); Liu et al. (; ); Touvron et al. () have attracted huge research interests. As outlined in Dai et al. (), the $O(N^{2})$-complex attention in ViTs is a notable issue from a data size and resource-constrained viewpoint. This issue continues to inspire improvements in ConvNets. For instance, RepLKNet Ding et al. () aims to bridge the gap between ViT and CNNs by employing large kernels.

The previously discussed designs focus on particular aspects, e.g., He et al. (); Xie et al. () on the accuracy, Chen et al. (); Goyal et al. () on runtime and depth. On the other hand, our aim is not to develop large-scale complex models. Instead, given the success of VanillaNet-style networks, we focus on our sub-objectives (Sec 1) to push the frontier of simple, concise models by revisiting the representative ConvNets.

## 3 Columnar Stage Network

Figure: (a)
Refer to caption: x2.png

Our approach is a series of improvements motivated by representative ConvNet designs. To understand better, we begin with ResNet He et al. () as a stepping stone as done in Liu et al. (). We design the building block of CoSNet i.e., CoSNet-unit while recalling our sub-objectives: $1)$ reducing depth, $2)$ controlled parameter count, $3)$ high computational density, $4)$ uniform primitive operation, and $5)$ low branching.

### 3.1 Avoiding 1 × 1 1 1 1\times 1 1 × 1 for Reducing Depth

The recent works of reducing depth Chen et al. (); Goyal et al. () increase the parameter count to achieve accuracy similar to a deeper network. However, we aim to reduce depth while avoiding a large parameter count, which is a difficult objective. Hence, we handle reducing depth and controlling parameter count separately.

To reduce depth, we identify that $1\times 1$ convolutions in the ResNet-like designs (Figure 2a) (He et al., ; Liu et al., ) etc., form almost $66\%$ of depth without improving receptive field due to their pointwise nature Luo et al. (). Hence, we minimize the number of these layers. Specifically, we use only two $1\times 1$ convolutions $L_{s}$ and $L_{f}$ in a CoSNet-unit, where $L_{s}$ reduces the channel squeezing while $L_{f}$ performs expansion (Figure 2b). Then, we stack $l$ number of $3\times 3$ convolutions, forming a column sandwiched between $L_{s}$ and $L_{f}$.

This strategy brings two benefits. First, it reduces the overall depth at the same receptive field, e.g., three blocks of ResNet-like design have $9$ layers with three receptive-field governing $3\times 3$ layers. In contrast, the proposed design only has $5$ layers, i.e., two $1\times 1$ and three $3\times 3$ conv, indicating a notable $45\%$ *depth reduction* with the same receptive field.

Second, the reduced depth results in reduced FLOPs and latency e.g., CoSNet performs better than ResNet-$50$ at $50\%$ fewer layers while having relatively fewer parameters, FLOPs, and latency.

### 3.2 Parallel Columnar Convolutions for Controlled Parameters.

We propose Parallel Columnar Convolutions to handle the large parameter count originating to compensate for the lost non-linearity due to the reduced depth Chen et al. (). In this design, we first deploy $M$ columns in parallel (Figure 2c), and crosstalk among columns does not exist, i.e. a convolution of a column can only feed a convolution of the same column. Then, we restrict the number of kernels in a convolution layer of a column to a small number of $N$. This design affects the number of parameters less aggressively when the number of columns increases (see ablations in the supplement). This is a powerful feature of CoSNet design, offering controlled growth of parameter count during network scaling. This helps CoSNet achieve higher accuracy with fewer parameters.

The idea of the parallel column is based on our hypothesis that multiple kernels with fewer channels can be better than one with large channels. Having $M$ convolutions in parallel with a smaller number of kernels $N$ is equivalent to synthesizing multiple kernels from a large kernel. On the other hand, the idea of smaller $N$ is motivated by the fact that many parallelly operating neurons tend to learn redundant representations while being computationally taxing and causing overfitting. For the same reason, EfficientViT Liu et al. () slices the input channels in its structure. Hence, by keeping $N$ small, we expect to decouple the data patterns learned by the different columns.

In ConvNets, a similar idea was proposed in Inception Szegedy et al. (), then in ResNeXt Xie et al. (), and then abandoned later as it caused inefficiency. For instance, Inception uses different-sized convolutions and pooling in parallel, which must be executed serially despite being employed in parallel. Also, Inception differs from our columnar architecture since it does not have columns as deep as CoSNet.

### 3.3 Input Replication

In CoSNet, all the columns are fed with replicas of the input. We achieve that via a simple Input Replication IR operation (Figure 2c), which transforms a tensor $\in\mathbb{R}^{C\times H\times W}$ into duplicated one $\in\mathbb{R}^{(M\times C)\times H\times W}$, where $M$ denotes the desired number of the columns. In the CoSNet-unit, the IR is applied over the output of the $L_{s}$ layer to feed each column with the input replica.

Input replication has also been employed in the earlier ResNeXt Xie et al. (), but notable differences exist. ResNeXt has multiple blocks per stage, and *each block performs* IR, as shown in Figure 1d. Whereas CoSNet performs IR only once. In ResNeXt, IR is performed before $1\times 1$ squeeze layer, whereas in CoSNet, it is done after the squeeze layer.

The parallel columnar organization may seem to overlap with widely explored group convolutions Xie et al. (); Zhang et al. (). However, there are two key differences. First, group convolution *divides the input channels*, thus defying the objective of IR because now each column receives only a subset of the input channels, thus less information per group, as shown in Figure 1g. On the contrary, CoSNet uses IR, which feeds each column with the replica of the input, thus making the entire input information accessible to each column. This becomes one of the reasons that despite infrequent fusion (Sec. 3.6), unlike group conv, CoSNet still performs better (See ablations in the supplement).

### 3.4 Uniform Kernel Size for High Computational Density & Uniform Primitive Operations.

The parallel columns of a CoSNet-unit can be executed independently; however, this design can be optimized further if all the convolutions in all the columns have uniform kernel size. To this end, we first set the kernel size in all the convolutions to $k\times k$, where $k\in\mathbb{R}_{\geq 3}$. Then, we combine the convolutions of different columns lying at the same level, i.e., the first convolution of each column is combined into one convolution having $M$ batches.

With this optimization, all columns can be efficiently processed using GPU-based highly optimized Batched-Matrix-Multiply routines, leading to increased computational density, increased GPU utilization, reduced memory access cost Ding et al. (), and minimized GPU load-dispatch transactions. Thus resulting in a simplified CoSNet design (Figure 2d).
Moreover, since an CoSNet-unit is made up mostly of $3\times 3$ convolutions, it well suits the convolution hardware accelerators because they have dedicated support for them, and more chip area can be dedicated to $3\times 3$ computational units.

### 3.5 Batched Processing for Minimal Branching.

From the previous step, batched processing yields additional benefits, i.e., CoSNet becomes uni-branched regardless of training and testing. This reduces memory consumption and access costs, resulting in lower per-iteration training time and increased parallelization. This contrasts with RepVGG Ding et al. (), which has a considerable training time. Regarding ASIC development, low branching in CoSNet leaves more area on the chip because of the reduced memory requirement to store intermediate tensors. This area can now be dedicated to more computational units.

Although the multi-branch design is beneficial for achieving high accuracy Ding et al. () (Figure 1f), CoSNet, despite having minimal branching, effortlessly achieves high accuracy. This is because the core design of CoSNet-unit posses multiple branches in the form of columns and short projections (Figure 2c). However, due to batched processing CoSNet-unit mimics uni-branched behavior. In this way, CoSNet takes advantage of both worlds, i.e., eliminated train time complexity due to multiple branches and fast inference during test time without needing structural parameterization Ding et al. ().

### 3.6 Fuse Once

Finally, the output of all the columns is fused by $L_{f}$. In ResNeXt (Figure 1d), the output of $3\times 3$ convs are fused immediately via a $1\times 1$ conv, whereas in CoSNet, it is done much later.
Our fuse once strategy is different from group Zhang et al. () or depthwise convolutions Howard et al. () that are followed by $1\times 1$ (Figure 1g) to avoid loss of accuracy because each group/channel has too few connections which restrict its learning ability without frequent fusion (Zhang et al. (), Figure 1g). This increases network depth and, hence, latency. On the contrary, CoSNet is free from this constraint because we increase $N$ as we go deep in CoSNet unlike Zhang et al. (). Hence, each neuron in $M$ columns has a sufficiently large number of connections that enable learning without frequent fusion. We performed an ablation (see supplement) by applying the same strategy as Figure 1g in CoSNet. We observed increased network depth, latency, and decreased accuracy.

Figure: Figure 3: Illustration of Vanilla Frequent Fusion (left) (Zhang et al. (), Figure 1g) and Pairwise Frequent Fusion (right).
Refer to caption: x3.png

Pairwise Frequent Fusion (PFF): Although we aim to reduce $1\times 1$ layers as they have a high concentration of most of the network parameters and FLOPs (Sec. 3.1), we propose a frequent fusion scheme via $1\times 1$ while avoiding the parameter and FLOPs concentration issue. In this scheme, instead of fusing all the columns simultaneously, we fuse columns only pairwise via $1\times 1$ (Figure 3). This strategy essentially offers several benefits. Firstly, with pairwise fusion, $1\times 1$ kernel incorporates only a few computations per layer due to small kernel size (fewer channels) while improving network accuracy. Secondly, the latency incorporated due to these layers does not increase the overall latency because of the few computations per layer, hence offers better accuracy with negligible latency overhead ($1-2$ms). See Table 1. We denote all such CoSNet variants as CoSNet-PFF.

### 3.7 Projections

To facilitate better gradient flow during network training, we employ projections introduced by ResNet He et al. () but slightly differently in two ways:

$1)$ Shallow Range. These projections are formed between any two layers of a column and promote better gradient flow through the stack of $l$ layers (Figure 2c). Since such projections connect only two layers, unlike a stack of layers in ResNet-like designs, these are named shallow ranges.

$2)$ Deep Range. These projections are formed between the input and the output of a CoSNet-unit. Specifically, the input to CoSNet-unit is projected to its output via a $3\times 3$ pooling layer followed by a $1\times 1$ convolution $L_{p}$ whose output is fused with the output of $L_{f}$ (Figure 2c). The pooling operation gathers spatial context by enlarging the receptive field, which is otherwise impossible for $L_{p}$ alone due to its point-wise nature.
We call it deep projection because it bypasses the entire columnar structure while combining information from the previous network stages, i.e., multi-layer information fusion, and providing a short alternative path for gradient flow.

The above projection design helps achieve CoSNet better accuracy (see ablations) and is slightly different from the existing ones. First, projection in ResNet-like models He et al. (); Xie et al. () is used only in the first block of a stage (shallower), and projection between stages does not exist. Second, projection in these models operates at a stride of $2$. On the contrary, in CoSNet, the projection connects two stages (deeper) while operating at unit stride and utilizing pooling to increase the receptive field.

### 3.8 CoSNet Instantiation

Figure: (a)
Refer to caption: x4.png

A CoSNet variant can be instantiated by stacking CoSNet-units (Figure 4). CoSNet does not have the notion of blocks but only has stages in the form of CoSNet-unit. This contrasts with existing ConvNets, which have stages, and each stage comprises multiple blocks Goyal et al. (); He et al. (); Liu et al. (); Xie et al. () e.g., ResNet-$50$ has four stages, having $3$, $4$, $6$, and $3$ blocks respectively (Figure 1c- 1e).

To instantiate a CoSNet variant, we follow the tradition of five stages He et al. (); Simonyan & Zisserman (), among which the first (stem) is a $3\times 3$ convolution with a stride of $2$, while the remaining are the CoSNet-units.

Following ResNet He et al. (), we set channels of $L_{s}$ to $64$, which gets doubled at each stage, while the channels of $L_{p}$ and $L_{f}$ always equal to $\zeta$ times the channels of $L_{s}$. We set $\zeta=4$, following He et al. (). To further simplify the instantiation, we set the depth of a column, i.e. $l$ in $k^{th}$ CoSNet-unit equal to the number of blocks in the $k^{th}$ stage of a widely used model ResNet-$50$ He et al. (). Summarily, CoSNet-unit has *only three hyperparameters: $M,N,l$* which can be changed to construct different CoSNet variant. Please refer to the supplement for CoSNet instance names.

## 4 Experiments

We evaluate CoSNet on ImageNet Deng et al. () dataset consisting of $1.28$M train and $50$k validation images of $1000$ categories. Our training methodology is consistent with recent VanillaNet Chen et al. (). We use data augmentation techniques in Chen et al. (); Liu et al. (). See the appendix at the end of this paper for more details.

**Table 1: Evaluation of CoSNet on ImageNet Deng et al. (). Latency is measured with batch size $1$. ‘SR’ denotes structural parameterization. ‘PFF’ stands for pairwise frequent fusion. See Sec 3.6 for details.**
| Architecture | Type | #Depth \contouraccclr$\downarrow$ | #Params \contouraccclr$\downarrow$ | FLOPs \contouraccclr$\downarrow$ | Latency \contouraccclr$\downarrow$ | FPS \contouraccclr$\uparrow$ | Top-$1$ ($\%$) \contouraccclr$\uparrow$ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| $\bullet$ ResNet-$18$ He et al. () | ConvNet | $18$ | $11.6$M | $1.83$B | $4$ms | $250$ | $71.1$ |
| $\bullet$ ResNet-$34$ He et al. () | ConvNet | $34$ | $21.7$M | $3.68$B | $8$ms | $125$ | $74.1$ |
| $\bullet$ ResNet-$50$ He et al. () | ConvNet | $50$ | $25.5$M | $4.12$B | $11$ms | $90$ | $76.3$ |
| $\bullet$ ResNet-$101$ He et al. () | ConvNet | $101$ | $44.5$M | $7.85$B | $15$ms | $67$ | $77.2$ |
| $\bullet$ ResNet-$152$ He et al. () | ConvNet | $152$ | $60.1$M | $11.50$B | $15$ms | $67$ | $77.8$ |
| $\bullet$ ResNeXt-$50$ Xie et al. () | ConvNet | $50$ | $25.1$M | $4.40$B | $11$ms | $90$ | $77.4$ |
| $\bullet$ ResNeXt-$101$ Xie et al. () | ConvNet | $101$ | $44.1$M | $8.10$B | $14$ms | $71$ | $78.4$ |
| $\bullet$ EfficientNet-B0 0 Tan & Le () | ConvNet | $49$ | $5.3$M | $0.40$B | $8$ms | $125$ | $75.1$ |
| $\bullet$ RegNetX-$12$GF Radosavovic et al. () | ConvNet | $57$ | $46.0$M | $12.10$B | $13$ms | $77$ | $80.5$ |
| $\bullet$ RepVGG-A0 0 Ding et al. () | ConvNet | $22$ | $8.3$M | $1.46$B | $4$ms | $250$ | $72.4$ |
| $\bullet$ RepVGG-A0 0 Ding et al. () w/o SR | ConvNet | $22$ | $9.1$M | $1.51$B | $8$ms | $125$ | $72.4$ |
| $\bullet$ RepVGG-A$1$ Ding et al. () | ConvNet | $22$ | $12.7$M | $2.36$B | $5$ms | $200$ | $74.4$ |
| $\bullet$ RepVGG-A$1$ Ding et al. () w/o SR | ConvNet | $22$ | $14.0$M | $2.63$B | $7$ms | $143$ | $74.4$ |
| $\bullet$ RepVGG-B0 0 Ding et al. () | ConvNet | $28$ | $14.3$M | $3.40$B | $5$ms | $200$ | $75.1$ |
| $\bullet$ RepVGG-B0 0 Ding et al. () w/o SR | ConvNet | $28$ | $15.8$M | $3.06$B | $7$ms | $143$ | $75.1$ |
| $\bullet$ RepVGG-A$2$ Ding et al. () | ConvNet | $22$ | $25.5$M | $5.12$B | $7$ms | $143$ | $76.4$ |
| $\bullet$ RepVGG-A$2$ Ding et al. () w/o SR | ConvNet | $22$ | $28.1$M | $5.69$B | $9$ms | $111$ | $76.4$ |
| $\bullet$ RepVGG-B$3$ Ding et al. () | ConvNet | $28$ | $110.9$M | $26.20$B | $17$ms | $58$ | $80.5$ |
| $\bullet$ RepVGG-B$3$ Ding et al. () w/o SR | ConvNet | $28$ | $123.0$M | $29.10$B | $22$ms | $45$ | $80.5$ |
| $\bullet$ ParNet-L Goyal et al. () | ConvNet | $12$ | $55.0$M | $26.70$B | $23$ms | $43$ | $77.7$ |
| $\bullet$ ParNet-XL Goyal et al. () | ConvNet | $12$ | $85.0$M | $41.50$B | $25$ms | $40$ | $78.5$ |
| $\bullet$ DeiT-S Touvron et al. () | Transformer | $48$ | $22.0$M | $4.60$B | $15$ms | $66$ | $79.8$ |
| $\bullet$ Swin-T Liu et al. () | Transformer | $96$ | $28.0$M | $4.50$B | $20$ms | $50$ | $81.1$ |
| $\bullet$ ViTAE-S Xu et al. () | Transformer | $116$ | $23.6$M | $5.60$B | $24$ms | $41$ | $82.0$ |
| $\bullet$ CoAtNet-0 Dai et al. () | Hybrid | $64$ | $25.0$M | $4.20$B | $15$ms | $66$ | $81.6$ |
| $\bullet$ ConvNeXt-T Liu et al. () | ConvNet | $59$ | $29.0$M | $4.50$B | $13$ms | $77$ | $81.8$ |
| $\bullet$ ConvNextV$2$-P Woo et al. () | ConvNet | $41$ | $9.1$M | $1.37$B | $11$ms | $90$ | $79.7$ |
| $\bullet$ ConvNextV$2$-N Woo et al. () | ConvNet | $47$ | $15.6$M | $2.45$B | $13$ms | $77$ | $81.2$ |
| $\bullet$ ConvNextV$2$-T Woo et al. () | ConvNet | $59$ | $28.6$M | $4.47$B | $16$ms | $62$ | $82.5$ |
| $\bullet$ EfficientViT-M$4$ Liu et al. () | Transformer | $42$ | $8.8$M | $0.30$B | $6$ms | $166$ | $74.3$ |
| $\bullet$ EfficientViT-M$5$ Liu et al. () | Transformer | $70$ | $12.4$M | $0.60$B | $7$ms | $142$ | $76.8$ |
| $\bullet$ VanillaNet-6 Chen et al. () | ConvNet | $6$ | $32.0$M | $6.00$B | $6$ms | $167$ | $76.3$ |
| $\bullet$ VanillaNet-8 Chen et al. () | ConvNet | $8$ | $37.1$M | $7.70$B | $6$ms | $167$ | $79.1$ |
| $\bullet$ VanillaNet-9 Chen et al. () | ConvNet | $9$ | $41.4$M | $8.60$B | $6$ms | $167$ | $79.8$ |
| $\bullet$ VanillaNet-10 Chen et al. () | ConvNet | $10$ | $45.7$M | $9.40$B | $7$ms | $142$ | $80.5$ |
| $\bullet$ CoSNet-A0 0 | ConvNet | $26$ | $8.8$M | $1.25$B | $6$ms | $167$ | $77.1$ |
| $\bullet$ CoSNet-A$1$ | ConvNet | $26$ | $12.1$M | $1.70$B | $6$ms | $167$ | $78.2$ |
| $\bullet$ CoSNet-B0 0 | ConvNet | $26$ | $19.8$M | $3.05$B | $7$ms | $143$ | $79.5$ |
| $\bullet$ CoSNet-B$1$ | ConvNet | $26$ | $22.0$M | $3.50$B | $7$ms | $167$ | $79.9$ |
| $\bullet$ CoSNet-B$2$ | ConvNet | $26$ | $30.0$M | $5.10$B | $9$ms | $111$ | $81.3$ |
| $\bullet$ CoSNet-C$1$ | ConvNet | $28$ | $24.4$M | $4.12$B | $7$ms | $143$ | $80.0$ |
| $\bullet$ CoSNet-C$2$ | ConvNet | $26$ | $38.9$M | $7.09$B | $11$ms | $90$ | $82.1$ |
| $\bullet$ CoSNet-A$1$-PFF | ConvNet | $38$ | $12.7$M | $1.93$B | $7$ms | $143$ | $79.7$ |
| $\bullet$ CoSNet-B0 0-PFF | ConvNet | $38$ | $21.8$M | $3.44$B | $8$ms | $125$ | $80.6$ |
| $\bullet$ CoSNet-B$1$-PFF | ConvNet | $38$ | $25.6$M | $4.08$B | $8$ms | $125$ | $81.4$ |
| $\bullet$ CoSNet-B$2$-PFF | ConvNet | $38$ | $34.3$M | $5.91$B | $10$ms | $100$ | $82.7$ |
| $\bullet$ CoSNet-C$1$-PFF | ConvNet | $42$ | $27.3$M | $4.75$B | $8$ms | $125$ | $81.3$ |
| $\bullet$ CoSNet-C$2$-PFF | ConvNet | $38$ | $44.5$M | $8.27$B | $13$ms | $77$ | $83.7$ |

### 4.1 Advanced ConvNets and Vision Transformers

CoSNet vs recent EfficientViT Liu et al. ()
As shown in Table 1 and Figure 5, CoSNet is less deep and runs $60\%$ faster than EfficientViT Transformer while exhibiting better accuracy, e.g., EfficientVit-M$4$ vs CoSNet-A0 0. EfficientVit is another example of lower FLOPs that do not guarantee lower latency. Even the CoSNet-A$1$-PFF variant is still relatively shallower than EfficientVit while delivering better accuracy.

CoSNet vs DeiT Touvron et al. ()
From Table 1, CoSNet-B$1$ is almost $50\%$ less deep, has $23\%$ fewer params, and runs $60\%$ faster than DeiT Transformer while exhibiting slightly better accuracy. With PFF, CoSNet-B0 0-PFF performs better in terms of accuracy, depth, and runtime.

CoSNet vs advanced mid-range ConvNets and Transformers
CoSNet-B$2$ is $72\%$ less deeper, $55\%$ faster, and $1.2\%$ more accurate than the popular Swin Transformer Liu et al. (). It is also $55\%$ less deeper, $30\%$ faster with slightly lower accuracy than the popular ConvNeXt Liu et al. (). Moreover, CoSNet-C$2$ rivals the latest ConvNext-v$2$-T Woo et al. () with similar accuracy but higher speed and smaller depth.

CoSNet-B$2$, C$1$, C$2$ models rivals advanced Transformers, such as ViTAE-S Xu et al. () and hybrid models, such as CoAtNet-0 Dai et al. (). With similar parameter counts and accuracy, our models show faster inference speed. The competitive tradeoffs offered by CoSNet show the significance of concise models.

Figure: Figure 5: Comparing the proposed CoSNet with representative models. Models in ‘ and ‘ refers to CoSNet and existing models respectively. CoSNet has lower parameters, lower FLOPs, while depth of CoSNet is not unnecessarily large. The size of the circle is proportional to the parameter count.
Refer to caption: x5.png

### 4.2 Comparison with Standard ConvNets

We show that CoSNet achieves efficiency in multiple aspects in a large spectrum of models while being simpler during training and inference and offering competitive trade-offs relative to the rival network. See Table 1 for the comparison. Figure 5 plots the trends regarding various aspects.

CoSNet vs recent VanillaNet Chen et al. ().
CoSNet rivals recent ConvNet design, VanillaNet. VanillaNet is shallow and mainly focuses on latency. Our CoSNet-A0 0 shows similar latency at fewer parameters, fewer FLOPs, and high accuracy compared with VanillaNet-$6$ (Table 1).

CoSNet vs recent ParNet Goyal et al. ().
CoSNet outperforms recent non-deep ParNet that focuses on lower latency (Table 1 R4). CoSNet is uni-branched, while ParNet has multiple shallow branches which serialize the computations, thus making them deeper virtually.

CoSNet vs RepVGG Ding et al. ().
RepVGG offers a plain VGG-like Simonyan & Zisserman () structure via Structural Reparameterization (SR). However, its training complexity is high due to a large number of parameters and three branches at each layer (Figure 1f). Hence, we show its performance with and without SR.

Compared with the RepVGG family, CoSNet offers considerably lower complexity during training and testing, thanks to its parallel columnar convolutions. In addition, CoSNet has fewer parameters and fewer FLOPs while offering similar speeds with higher accuracy. For instance, CoSNet-B$2$ is better than RepVGG-B$3$ at similar depth, $73\%$ fewer parameters, $80\%$ lesser FLOPs while running faster. This shows the significance of parallel columns of CoSNet that during model scaling, parameter count does not grow rapidly.

CoSNet vs EfficientNet Tan & Le ().
Although we do not aim for a mobile regime in this paper, we show that having fewer parameters and FLOPs does not guarantee faster speeds. As shown in Table 1, EfficientNet-B0 0 has $50\%$ fewer parameters and $77\%$ fewer FLOPs, but is $50\%$ deeper, and runs $37\%$ slower. By exploring the design space, CoSNet can be extended to the mobile regime.

CoSNet vs ResNet He et al. () family.
As shown in Table 1, CoSNet-A0 0 is $6\%$ more accurate, has $25\%$ fewer parameters, shows similar runtime, and shows $31\%$ fewer FLOPs than ResNet-$18$ although CoSNet has $6$ more layers. Similarly, in contrast to ResNet-$34$, it is more accurate by $3\%$ with $59\%$ fewer parameters, $66\%$ fewer FLOPs, and $23\%$ less layers, while it is fast by $37\%$.
ResNet-$50$ is the widely employed backbone in downstream tasks Carion et al. (); Goyal et al. (); He et al. (); Ren et al. () due to its affordability regarding representation power, FLOPs, depth, and accuracy. Table 1 shows that CoSNet-B0 0 surpasses ResNet-$50$ while being $50\%$ shallower, $22\%$ fewer parameters, $25\%$ fewer FLOPs, and $40\%$ faster.

CoSNet vs bigger ResNet He et al. () and ResNeXt Xie et al. () models.
As shown in Table 1, CoSNet-C$1$ is better than bigger variants of ResNet, which serves as backbones for cutting-edge works Carion et al. (); Li et al. (). Our CoSNet outperforms them in various aspects while being $72\%$ and $82\%$ less deep relative to ResNet-$101$ and ResNet-$152$, respectively. CoSNet also runs faster by $50\%$ in $50\%$ fewer parameters and FLOPs.
In addition, despite being smaller than ResNeXt Xie et al. (), CoSNet-C$1$ outperforms it in various aspects. Overall CoSNet-C$1$ is $50\%$ less deeper than ResNeXt-$50$ while running $50\%$ faster at $6\%$ fewer FLOPs, $2\%$ fewer parameters while being more accurate. In contrast to ResNeXt-$101$, CoSNet-C$2$ is $75\%$ less deeper, $11\%$ fewer parameters, $12\%$ fewer FLOPs, and $35\%$ faster at a higher accuracy.

**Table 2: Comparison with VannilaNet Chen et al. () in training.**
| Architecture | #Depth\contouraccclr$\downarrow$ | #Epochs\contouraccclr$\downarrow$ | #Params\contouraccclr$\downarrow$ | #FLOPs\contouraccclr$\downarrow$ | Top-$1$ ($\%$)\contouraccclr$\uparrow$ | Train Time Per Epoch \contouraccclr$\downarrow$ | Train Time $300$ Epochs \contouraccclr$\downarrow$ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| $\bullet$ VanillaNet-6 Chen et al. () | $6$ | $300$ | $32.0$M | $6.00$B | $76.36$ | $8$ minutes | $40$ hours |
| $\bullet$ VanillaNet-8 Chen et al. () | $8$ | $300$ | $37.1$M | $7.70$B | $79.13$ | $11$ minutes | $55$ hours |
| $\bullet$ CoSNet-B$\mathbf{1}$ | $26$ | $300$ | $\mathbf{19.8}$M | $\mathbf{3.05}$B | $\mathbf{79.50}$ | $\mathbf{5}$ minutes | $\mathbf{25}$ hours |

**Table 3: CoSNet with SE-like modules Hu et al. ().**
| Approach | #Epochs | #Depth | #Params | #FLOPs | Top-$1$ ($\%$) |
| --- | --- | --- | --- | --- | --- |
| $\bullet$ ResNet-$50$ + SE Hu et al. () | $120$ | $50$ | $28.0$M | $4.13$B | $76.85$ |
| $\bullet$ ResNet-$50$ + CBAM Woo et al. () | $120$ | $50$ | $28.0$M | $4.13$B | $77.34$ |
| $\bullet$ CoSNet-B$\mathbf{1}$ | $120$ | $\mathbf{26}$ | $\mathbf{19.2}$M | $\mathbf{3.05}$B | $\mathbf{76.77}$ |
| $\bullet$ CoSNet-B$\mathbf{1}$ + SE Hu et al. () | $120$ | $\mathbf{26}$ | $\mathbf{20.1}$M | $\mathbf{3.10}$B | $\mathbf{77.85}$ |
| $\bullet$ ResNet-$50$ + AFF Dai et al. () | $160$ | $50$ | $30.3$M | $4.30$B | $79.10$ |
| $\bullet$ ResNet-$50$ + SKNet Li et al. () | $160$ | $50$ | $27.7$M | $4.47$B | $79.21$ |
| $\bullet$ CoSNet-C$\mathbf{1}$ + SE Hu et al. () | $160$ | $\mathbf{28}$ | $\mathbf{25.0}$M | $\mathbf{4.13}$B | $\mathbf{79.51}$ |

### 4.3 Additional Experiments

CoSNet has small training walltime. We provide an additional comparison with the recent ConvNet design, VanillaNet Chen et al. (), under training settings. Table 2 shows that despite VanillaNet being a shallow network, it has a high training time. We speculate that the large number of channels in the deeper layers of VanillaNet slows down batch processing at large batch sizes. In CoSNet, parallel columnar convolutions and controlled parameter growth in the deeper layers counter this issue, leading to lower training time.

CoSNet is seamlessly compatible with SE-like Hu et al. () modules. Table 3 shows the results when CoSNet is used in conjunction with Squeeze and Excitation (SE) like modules Hu et al. (). It outperforms recent attention mechanism (AFF Dai et al. (), SKNet Li et al. (), and CBAM Woo et al. ()) applied to ResNet-50.

**Table 4: CoSNet in state-of-the-art Detection Transformers (DETR) Li et al. () @$12$ epochs setting.**
| Method | #Params | #FPS | AP | AP50 | AP75 | APS | APM | APL |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| $\bullet$ DN-DETR-ResNet$50$ Li et al. () | $44$M | $24$ | $38.3$ | $59.1$ | $41.0$ | $17.3$ | $42.4$ | $57.7$ |
| $\bullet$ DN-DETR-CoSNet-C$\mathbf{2}$ | $56$M | $\mathbf{25}$ | $39.2$ | $60.0$ | $41.9$ | $18.1$ | $43.0$ | $59.1$ |

### 4.4 CoSNet in State-of-the-art Detection Transformer

We apply CoSNet to state-of-the-art object Detection Transformer, DN-DETR Li et al. () to demonstrate the effectiveness of CoSNet in the downstream task.
We experiment on MS-COCO Lin et al. () benchmark and utilized DN-DETR’s default training settings.

Table 4 shows that DN-DETR with CoSNet improves the inference speed and average precision compared to the DN-DETR with ResNet-50 backbone. By further optimizing the DETR hyperparameters, CoSNet can be configured to deliver better performance.

### 4.5 Visualization of Attention

Figure: Figure 6: CAM Srinivas & Fleuret () visualizations. Notably, CoSNet attends the class regions more accurately than the baseline.
Refer to caption: extracted/5903572/images/fullgrad_comnetb1/3000.png

To comprehend CoSNet’s better performance, we investigate its class activation maps (CAM) on ImageNet Deng et al. () validation set. We use CAM output from popular Full-Grad-CAM Srinivas & Fleuret () for a given class. CAM visualizations of ResNet-$50$ and CoSNet-B$1$ are shown in Figure 6. It can be seen that CoSNet, despite being $50\%$ shallower than ResNet, is better at learning to attend regions of the target class relative to the baseline.

## 5 Conclusion

We propose CoSNet, which revisits ConvNet design based on multiple aspects for concise models. CoSNet is based on our parallel columnar convolutions and input replication concepts to be efficient in parameters, FLOPs, accuracy, latency, and training duration. Through extensive experimentation and ablations, we show that CoSNet rivals many representative ConvNets and ViTs such as ResNet, ResNeXt, RegNet, RepVGG, and ParNet, VanillaNet, DeiT, EfficientViT while being shallower, faster, and being architecturally simpler.

Limitations. CoSNet is open for improvement. In this paper, we have built a simple template architecture that can further evolve like ConvNext Liu et al. (). For instance, a comprehensive design space of CoSNet including mobile regime can be explored, similar to RegNet Radosavovic et al. (). Besides, layer merging post-training, shown in VanillarNet Chen et al. (), can be utilized to develop more shallower variants of CoSNet. In addition to that, CoSNet can also be married with a Transformer attention mechanism like Dai et al. () or Liu et al. ().

## Appendix

## Appendix A CoSNet Instances

Table A1 shows CoSNet instances configurations mentioned in the main paper.

**Table A1: CoSNet instances Configurations.**
| Model | $P_{c}$ | $N$ | $l$ | $M$ | #Depth | #Params | #FLOPs |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| $\bullet$ CoSNet-A0 0 | $256$ | $512$ | $1024$ | $2048$ | $16$ | $32$ | $64$ | $128$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | $8.8$M | $1.25$B |  |
| $\bullet$ CoSNet-A$1$ | $256$ | $512$ | $1024$ | $2048$ | $16$ | $32$ | $64$ | $128$ | $3$ | $4$ | $6$ | $3$ | $4$ | $4$ | $4$ | $4$ | $26$ | $12.1$M | $1.77$B |  |
| $\bullet$ CoSNet-B0 0 | $256$ | $512$ | $1024$ | $2048$ | $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $4$ | $4$ | $4$ | $4$ | $26$ | $19.8$M | $3.05$B |  |
| $\bullet$ CoSNet-B$1$ | $256$ | $512$ | $1024$ | $2048$ | $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $5$ | $5$ | $5$ | $5$ | $26$ | $22.6$M | $3.51$B |  |
| $\bullet$ CoSNet-B$2$ | $256$ | $512$ | $1024$ | $2048$ | $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $4$ | $4$ | $16$ | $4$ | $26$ | $30.0$M | $5.1$B |  |
| $\bullet$ CoSNet-C$1$ | $256$ | $512$ | $1024$ | $2048$ | $48$ | $80$ | $144$ | $272$ | $4$ | $4$ | $6$ | $4$ | $4$ | $4$ | $4$ | $4$ | $28$ | $24.4$M | $4.12$B |  |
| $\bullet$ CoSNet-C$2$ | $256$ | $512$ | $1024$ | $2048$ | $48$ | $80$ | $144$ | $272$ | $3$ | $4$ | $6$ | $3$ | $6$ | $6$ | $16$ | $6$ | $26$ | $38.9$M | $7.09$B |  |

**Table A2: Effect of parallel columnar convolution (PCC), # of kernels $N$, # of layers $l$, # of parallel convolutions $M$, and Deeper projections (DP). Values of $M,N,l$ are for each of the four CoSNet stages. Ablations are conducted at $120$ epochs.**
| Row | $N$ | $l$ | $M$ | #Depth | DP | Residual in PCC | #Params | #FLOPs | Top-$1$ ($\%$) |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| R0 0 | $\bullet$ $16$ | $32$ | $64$ | $128$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | ✓ | ✓ | $8.80$M | $1.25$B | $74.45$ |
| R$1$ | $\bullet$ $16$ | $32$ | $64$ | $128$ | $3$ | $4$ | $6$ | $3$ | $4$ | $4$ | $4$ | $4$ | $26$ | ✓ | ✓ | $12.1$M | $1.77$B | $75.65$ |
| R$2$ | $\bullet$ $16$ | $32$ | $64$ | $128$ | $3$ | $4$ | $6$ | $3$ | $5$ | $5$ | $5$ | $5$ | $26$ | ✓ | ✓ | $13.2$M | $1.95$B | $76.01$ |
| R$3$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | ✓ | ✓ | $11.3$M | $1.65$B | $75.37$ |
| R$4$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $4$ | $4$ | $4$ | $4$ | $26$ | ✓ | ✓ | $19.8$M | $3.05$B | $76.76$ |
| R$5$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $5$ | $5$ | $5$ | $5$ | $26$ | ✓ | ✓ | $22.6$M | $3.51$B | $77.01$ |
| R$6$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | ✓ | ✗ | $11.3$M | $1.65$B | $75.28$ |
| R$7$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | ✓ | ✓ | $11.3$M | $1.65$B | $75.37$ |
| R$8$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $4$ | $5$ | $20$ | $3$ | $1$ | $1$ | $1$ | $1$ | $44$ | ✓ | ✗ | $13.4$M | $2.12$B | $75.18$ |
| R$9$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $4$ | $5$ | $20$ | $3$ | $1$ | $1$ | $1$ | $1$ | $44$ | ✓ | ✓ | $13.4$M | $2.12$B | $75.88$ |
| R$10$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | ✗ | ✓ | $8.5$M | $1.29$B | $73.61$ |
| R$11$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | w/o. Pooling | ✓ | $9.8$M | $1.44$B | $74.15$ |
| R$12$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $1$ | $1$ | $1$ | $1$ | $26$ | w. Pooling | ✓ | $9.8$M | $1.44$B | $75.37$ |
| R$13$ | $\bullet$ $32$ | $64$ | $128$ | $256$ | $3$ | $4$ | $6$ | $3$ | $4$ | $4$ | $4$ | $4$ | $26$ | ✓ | ✓ | $19.8$M | $3.51$B | $76.76$ |
| R$14$ | $\bullet$ $32$ | $32$ | $32$ | $32$ | $3$ | $4$ | $6$ | $3$ | $4$ | $8$ | $16$ | $32$ | $26$ | ✓ | ✓ | $18.4$M | $3.42$B | $71.20$ |

## Appendix B Ablation Study

Varying $\mathbf{M}$ and $\mathbf{N}$.
Table A2 demonstrates the effect of varying $N$ and $M$ (R0 0-R$5$). We first fix the values of $N$ and vary $M$ (R0 0-R$5$), and then vary $M$ while fixing $N$ (R0 0 $\leftrightarrow$ R$3$, R$1$ $\leftrightarrow$ R$4$, R$2$ $\leftrightarrow$ R$5$). For fixed $N$, accuracy improves by increasing $M$, and the same effect is seen by fixing $M$ while varying $N$.
It can be noticed that parameters, FLOPs can be controlled by changing the $M$ (R$1$ $\leftrightarrow$ R$2$, R$4$ $\leftrightarrow$ R$5$), which directly reflects accuracy.

Effect of PCC.
We compare instances having different $N,M$, but have similar parameters and FLOPs budget, for instance, R$1$ $\leftrightarrow$ R$2$, R$1$ $\leftrightarrow$ R$3$, Table A2. Noticeably, $R2$ with $5$ PCC is better by $0.36\%$ in accuracy, only at $1.1$M more parameters relative to R$1$. Similarly, $R1$ is better by $0.28\%$ in accuracy, only at $0.8$M more parameters relative to R$3$. It shows that multiple PCCs facilitates improved accuracy in just a fraction of parameters and FLOPs. Moreover, if comparing R$9$ (a deeper model) with R$2$, R$2$ achieves $0.13\%$ more accuracy in $0.2$M fewer parameters and $0.17$B fewer FLOPs. It shows the advantage of *having multiple convolutional modules while being shallower*.

Varying $\mathbf{l}$.
The impact of varying $l$ is shown in R$9$, Table A2. It can be seen that *going deeper is not necessary* because a shallower version with same parameters (R$2$) is more accurate. Moreover, increased depth causes increased latency in R$9$. Therefore, we stick to $20-40$ layers of depth.

Group Convolution or ResNext-like Xie et al. () Setting
We also conduct additional experiments where each PCC is followed by a $1\times 1$ convolution as done in group convolutions while keeping depth and parameters constant. We observe a $1\%$ accuracy drop. This indicates that frequent fusion similar to ResNeXt is not necessary.

Effect of Shallow Projections in PCC.
R$6$-R$9$, Table A2 shows this analysis. For the shallower model, the residual connection shows only minor improvement ($0.09\%$), however, for the deeper model, the effect of residual connections is noticeable ($0.70\%$).

Effect of Deep Projections (DP).
We train an CoSNet instance in three ways: First, remove DP entirely, Second, use DP without pooling, and Third, DP with pooling. See Table A2 for the analysis. It can be noticed that without DP (R$10$), the model suffers with heavy accuracy loss of $\sim 0.54\%$ relative to when DP is used without pooling (R$11$). Moreover, when using DP with pooling (R$12$), accuracy improves, i.e., $1.22\%$ and $1.76\%$ relative to R$11$ and R$10$, respectively, because pooling provides more spatial context to the $1\times 1$ $L_{p}$ layer by summarizing the neighborhood.

Effect of using very small $N$ to compare with Group Convs Zhang et al. () and depthwise Conv-like Howard et al. () structure.
From Table A2, R$13$-$14$, it can be seen that when in deeper layers, $N$ is restricted to a very smaller value while keeping parameters or FLOPs the same, accuracy decreases considerably. This is because of the reason mentioned in the main paper (Sec.“Fuse-Once”) that too few connections restrict the learning ability of neurons. Hence, they need frequent fusion similar to GroupWise and Depthwise convolution methods, but it increases depth. To avoid that, we increase $N$ as we go deep down in CoSNet, which does not require frequent fusion due to a sufficiently large number of neuron connections. Thus, we fuse only once, eliminating the need for fusion $1\times 1$ layers, thus smaller depth and lower latency.

## Appendix C Training setting

We train models in PyTorch pytorch using eight NVIDIA A40 GPUs.

## Appendix D PyTorch Code

All codes shall be open-sourced in PyTorch pytorch post the review process. Here, we provide a code snippet of a CoSNet-Unit. Please see until the end of this document.

## Appendix E Complete Network Visualization

We also visualize the complete architecture of CoSNet-B1 variant and have put it in the context of ResNet-like models. We have plotted ResNet-$50$ variant. Please see Figure A1.

Figure: (a)
Refer to caption: x9.png

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. what's the difference between group conv and parallel columnar conv?
2. How much of efficiency and accuracy gain can be translated downstream to segmentation and detection work?
3. What's the memory overhead with the input replication?
4. How much depth is required for deep projection to have significant impact?
5. I see some similarity between PFF and self-attention modules in transformer. What's the performance like if using some fusing all columns simultaneously?
soundness: 3
strengths: This paper revisits some of the fundamental design ideas in conv net and proposed some interesting ideas. 
1. Shallow-deep projection is quite interesting. This inherits ideas from ResNet and expands to deep connection. 
2. It achieves competitive performances (accuracy and latency) with reduced network depth and parameters counts. 
3. It also introduces a pairwise frequent fusion (PFF) to fuse information across different columns.
summary: This paper introduces Columnar Stage Network (CoSNet) to deploy parallel conv units with fewer kernels, and reduce the 1x1 conv layers. To optimize the model efficiency, this paper follows the design objectives to reduce depth and branching, as well as to control the parameter growth, maintain computation intensity and uniform primitive operations.
weaknesses: Please refer to the questions section, where some clarity or more experiments would be great.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. Some details are missing.  For example, how is the value of parallel convolution M determined? I think that different values of M will affect the performance. Please explain this details in the text. Other minor issues, such as Section 3.4 is missing in Figure 2 (c), and you should add it.
2. How is the design like "input replication" to improving performance for example? Authors need to give some details in the manuscript.
3. The related work is comprehensive. However, the authors only highlight the salient features of the previous works that they apply in their network. The manuscript can benefit from discussing shortcomings of the existing methods as research gaps in the section "Related Work".
soundness: 3
strengths: 1. The writing is easy to read and clearly explains everything in the paper.
2. The experimental result is good compared to the previous works. Empirically, the method seems to offer strong accuracy, compared to existing methods with similar architectures.
summary: This paper proposes a simple and concise structure called CoSNet, which has smaller depth, low parameter count, low FLOPs, and attention less operations, well suited for resource-constrained deploy. The work presents a range of experiments that sufficiently support its claims. It is very  interesting for readers.

Overall, it is a good read. The manuscript might get better if a few suggestions (given below) are incorporated.
weaknesses: 1. Some details are missing.  For example, how is the value of parallel convolution M determined? I think that different values of M will affect the performance. Please explain this details in the text. Other minor issues, such as Section 3.4 is missing in Figure 2 (c), and you should add it.
2. How is the design like "input replication" to improving performance for example? Authors need to give some details in the manuscript.
3. The related work is comprehensive. However, the authors only highlight the salient features of the previous works that they apply in their network. The manuscript can benefit from discussing shortcomings of the existing methods as research gaps in the section "Related Work".

---

confidence: 5
contribution: 3
initial_rating: 3
presentation: 3
questions: As listed in Weaknesses
soundness: 3
strengths: 1. The motivation is reasonable. 
2. The result is comparable with the state-of-the-art.
3. The paper is easy to understand.
summary: This paper introduces a refreshing ConvNet macro design called Columnar Stage Network (CoSNet) with smaller depth, low parameter count, low FLOPs, and attention-less operations. 
Its comprehensive evaluations show that CoSNet rivals many renowned ConvNets and Transformer designs under resource-constrained scenarios.
weaknesses: 1. Typo: VanillaNet is published in NeurIPS 2023, instead of 2024.
2. Lack of some new comparison methods, all models were published in 2023 and even earlier. 
   The author should provide more comparisons like InceptionNeXt[1] and UniRepLKNet [2]. 
3. The Top-1 accuracy of EfficientNet-B0 is 76.3 [3] or 77.1 [4], but the author gives a much poorer result of 75.1. 
   Similar problems also happen on ConvNeXt-T (82.1 in [5] but 81.8 in this paper) and EfficientViT-M5 (77.1 in [6] but 76.8 in this paper, and 522M FLOPs in [6] and 600M in this paper). 


[1] InceptionNeXt: When Inception Meets ConvNeXt. CVPR 2024
[2] UniRepLKNet: A Universal Perception Large-Kernel ConvNet for Audio, Video, Point Cloud, Time-Series and Image Recognition. CVPR 2024
[3] EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks. ICML 2019
[4] EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks. arXiv 2019
[5] A ConvNet for the 2020s. CVPR 2022
[6] EfficientViT: Memory Efficient Vision Transformer with Cascaded Group Attention. CVPR 2023

Meta-review: This paper presents CoSNet, a series of network architectures of convolutional architectures to improve the efficiency of deep neural networks. At the core of this work lies a lot of model designs and adjustments; finally, an efficient architecture is obtained and works well in image classification.

The strengths of this work include:
* The proposed architecture seems simple and effective.
* Latency is tested which means the network enjoys runtime efficiency.

The weaknesses of this work include:
* The architecture has not been thoroughly tested for downstream tasks such as detection and segmentation.
* It seems difficult for the designed architecture to adapt to the transformer architecture for multimodal understanding; more importantly, given the prosperity of the vision transformer ecosystem, the advantage of model design will be largely reduced because vision transformers can benefit from a lot of other algorithms and pre-training data and/or pre-trained models.

All reviewers suggest borderline acceptance. Although the paper has clear limitations (see above), the AC finds no fatal reasons to overturn the reviewers' recommendation. However, the AC will not be upset if the SAC eventually decides to reject it. **If this paper is accepted, the AC strongly recommends the authors to add results on downstream recognition tasks in the final version.**

Decision: Accept (Poster)