Block State-based Recursive Networks (BSRN)

• BSRN is a neural architecture that uses discrete block state tensors to decouple historical context from transient feature maps for stable recursive refinement.
• It integrates parameter-shared Recursive Residual Blocks and transformer-style attention to efficiently process high-dimensional inputs.
• BSRN achieves competitive super-resolution and long-context modeling performance with fewer parameters and reduced computational complexity compared to traditional methods.

The Block State-based Recursive Network (BSRN) is a neural architecture paradigm emphasizing discrete block-wise state propagation and stateful recurrence. Originating in single-image super-resolution (SR), BSRN generalizes RNN-like “state plus input” computation into a blockwise recursive structure, decoupling current feature refinement from historical context by introducing dedicated state tensors. This motif enables highly parameter-efficient, stable, and progressive models applicable to both convolutional feature processing and transformer-style blockwise attention (Choi et al., 2018, Hutchins et al., 2022).

1. Architectural Principles of Block State-based Recurrence

BSRN’s core innovation is the introduction of an explicit “block state” tensor $S_t$—distinct from transient feature maps—to carry historical information across recursive steps. This separation stabilizes activations and prevents destructive overwriting inherent in naive parameter-sharing RNN-style networks.

• Recursive Residual Block (RRB): In convolutional BSRN, recursive steps operate via a parameter-shared block (“RRB”) receiving $(H_t, S_t)$ and producing $(H_{t+1}, S_{t+1})$. This mirrors RNN update schemes, but with state tensor $S_t$ tracking “memory” orthogonally to local feature activations.
• Blockwise Recurrence: In transformer variants, entire blocks of input tokens and state slots are processed per recurrence. The transition function for each block is implemented via self-attention and cross-attention (for feature and state interactions), with gating analogous to LSTM/Highway mechanisms (Hutchins et al., 2022).

A plausible implication is that the block-state formalism subsumes classical RNNs, enabling operations over high-dimensional and parallelized input blocks, yielding both enhanced expressivity and computational advantages in practice.

2. Mathematical Formulation

Formally, at recursion $t$ the block state and feature tensors are defined as:

• $H_t \in \mathbb{R}^{w \times h \times c}$ — image features at step $t$
• $S_t \in \mathbb{R}^{w \times h \times s}$ — persistent block state

The update equations are: $$s_t = F(s_{t-1}, h_{t-1}; \theta), \qquad h_t = G(s_t, h_{t-1}; \phi)$$ or in unified notation: $$(H_{t+1}, S_{t+1}) = \mathrm{RRB}(H_t, S_t; \theta_\mathrm{rrb})$$ with $F$ and $G$ parameterized as convolutional or attention-based transformations, depending on the domain.

For transformers and sequence models, the block segmentation yields: $$X_t \in \mathbb{R}^{B \times d}, \quad S_t \in \mathbb{R}^{S \times d}$$ and the core recurrence is: $(S_t, Y_t) = \text{RecCell}(S_{t-1}, X_t)$ where RecCell implements attention flows and gating.

LSTM-style gates in BRT modulate state updates: $\tilde S_t = \tanh(W_z H_t + U_z S_{t-1} + b_z)$

$$i_t = \sigma(W_i H_t + U_i S_{t-1} + b_i),\quad f_t = \sigma(W_f H_t + U_f S_{t-1} + b_f)$$

$S_t = f_t \odot S_{t-1} + i_t \odot \tilde S_t$

3. Detailed BSRN/Block-Recurrent Architectures

3.1 Convolutional BSRN for Super-Resolution (Choi et al., 2018)

• Initial feature extraction:

$H_0 = W_I \ast X + b_I$

• RRB: 3 cascaded C-Conv + C-ReLU layers, with two skip connections on $H$; block state initialized as $S_0 = 0$.
• Progressive fusion: Intermediate high-resolution outputs $\hat Y_t$ at every $r$ recursions, fused via weighted average for final prediction.
• Upscaling: Sub-pixel convolution upsamples $H_R$ to output resolution.

3.2 Block-Recurrent Transformer (BRT) (Hutchins et al., 2022)

• Partition token sequence into blocks $X_t$.
• Maintain blockwise state $S_t$, typically sized as number of tokens per block.
• Each recurrence uses standard transformer-layer operations: token self-attention, state self-attention, cross-attention between state and tokens.
• LSTM/Highway gating replaces horizontal residual connections.

Summary Table: Core BSRN Components

Component	BSRN SR (Conv)	BRT (Transformer)
State tensor	$S_t \in \mathbb{R}^{w \times h \times s}$	$S_t \in \mathbb{R}^{S \times d}$
Recurrence function	Parameter-shared Conv	Self-/Cross-Attn + Gate
Intermediate outputs	Fused HR predictions	Output blocks $Y_t$

4. Computational Complexity and Efficiency

BSRN’s block-based recursion yields significant efficiency advantages compared to deep stacking or full-sequence attention:

• Parameter Efficiency: In SR, state-of-the-art PSNR/SSIM is achieved with 30–70% fewer parameters compared to prior models (e.g., BSRN: 742K vs. CARN: 1,112K for $4\times$ SR on Set5 benchmark) (Choi et al., 2018).
• FLOPs: For convolutional BSRN, $R=16$, $c=s=64$, $w=h=64$, total $\sim 4.8 \times 10^{10}$ ops per image.
• Transformer Variant: For $N$ tokens, block size $B$, state slots $S$, complexity per sequence is $\Ocal((B^2 + S^2 + 2BS)(N/B))$. With $S=B$, scaling becomes $\Ocal(BN)$, matching the linear complexity of efficient transformer architectures.
• Intra-block Parallelism: All tokens and state slots within a block attend in parallel, exploiting accelerator hardware efficiently.
• Inference Time: BSRN achieves real-time inference (e.g., 0.027s/image for $4\times$ SR, up to 30 FPS) (Choi et al., 2018); BRT demonstrates over 2× speedup vs. long-range Transformer-XL (Hutchins et al., 2022).

5. Empirical Results and Benchmark Comparisons

Quantitative evaluation of BSRN for image SR shows competitive or superior performance at reduced cost:

Scale	Method	Params	Set5 (PSNR/SSIM)	BSD100	Urban100
×2	CARN	964K	37.76/0.9590	32.09	31.51
×2	BSRN	594K	37.78/0.9591	32.11	31.92
×4	CARN	1,112K	32.13/0.8937	27.58	26.07
×4	BSRN	742K	32.14/0.8937	27.57	26.03

BSRN delivers competitive PSNR/SSIM, particularly matching or exceeding state-of-the-art with a smaller computational footprint (Choi et al., 2018).

For BRT, perplexity improvements over Transformer-XL on long-context benchmarks (PG19, arXiv, GitHub) yield 5–13% relative bits-per-token reductions at equal or lower computational cost (Hutchins et al., 2022).

6. Benefits, Trade-offs, and Future Directions

Benefits

• Decoupled state enables stable recursive refinement and progressive inference.
• Parameter sharing via block state preserves history without over-writing.
• Linear complexity in sequence length for transformer BSRNs.
• Multi-stage outputs and weighted fusion yield improved final predictions.

Trade-offs

• Increased state size incurs modest parameter growth in block-specific layers.
• Recursion depth versus latency: more recursions yield marginal gains at the expense of speed.
• Output frequency control $r$ allows adjustable trade-off between speed and multi-stage refinement.

Future Directions

• Application of channel-wise or attention gates on block state tensors.
• Adaptive recurrence: variable block state updates per spatial or sequence region.
• Cross-modal extensions (e.g., video SR with temporal state), quantization/pruning for resource-limited deployment.
• Integration of cache-based sliding-window attention for ultralong contexts in language modeling (Hutchins et al., 2022).

7. Contextual Significance and Design Implications

BSRN generalizes the concept of recurrent state propagation beyond classical RNNs, enabling highly efficient models in convolutional and attention-based domains. The explicit block state design stabilizes feature representations, facilitates long-range credit assignment, and allows seamless integration of parallelism and gating mechanisms. Implementations leveraging existing Transformer and CNN blocks can achieve state-of-the-art performance on a range of tasks, notably single-image super-resolution and long-context sequence modeling (Choi et al., 2018, Hutchins et al., 2022).

A plausible implication is that BSRN architectures occupy a distinct region of the network design space wherein recurrence and parallelism are simultaneously maximized, yielding scalable solutions to tasks previously constrained by quadratic attention or deep stacking.