cortico-cerebellar-modularity-rnn

---
name: cortico-cerebellar-modularity-rnn
description: "Cortico-cerebellar modularity as architectural inductive bias for efficient temporal learning. CB-RNN architecture combining recurrent cortex with cerebellar feedforward module for fast temporal processing. Activation: cerebellar RNN, cortico-cerebellar, CB-RNN, temporal learning, modular RNN, cerebellar module, reservoir computing, temporal processing efficiency."
---

# Cortico-Cerebellar Modularity for Temporal Learning

> CB-RNN architecture combining a recurrent cortical core with a cerebellar-inspired feedforward module achieves faster learning and higher performance on temporal tasks, revealing that the cerebellum can serve as primary driver of learning efficiency while cortex functions as fixed reservoir.

## Metadata
- **Source**: arXiv:2605.10356
- **Authors**: Alexandra Voce, Emmanouil Giannakakis, Claudia Clopath
- **Published**: 2026-05-11
- **Categories**: q-bio.NC (Neurons and Cognition)

## Core Methodology

### Key Innovation
The cerebellum and cerebral cortex form tightly coupled circuits in biology that support flexible and efficient temporal processing. This paper translates that biological insight into an artificial architecture:

1. **Cortico-Cerebellar RNN (CB-RNN)**: Augments a standard RNN with a cerebellar-inspired feedforward module
2. **Heterogeneous Modularity**: Unlike homogeneous RNNs, the CB-RNN has structurally distinct components (recurrent + feedforward) that play complementary roles
3. **Cortex-as-Reservoir Finding**: After minimal training, freezing the recurrent core and delegating subsequent learning to the cerebellar module preserves superior efficiency — suggesting the cortical network functions largely as a fixed reservoir

### Technical Framework

**Architecture:**
```
Input → [Cortical RNN (recurrent core)] → [Cerebellar Module (feedforward)] → Output
                      ↓
                (can be frozen after initial training)
```

**Key Properties:**
- CB-RNN learns faster than parameter-matched fully recurrent baselines
- Reaches higher maximum performance across various task difficulty regimes
- Cerebellar module is the primary driver of learning efficiency
- Cortical core can function as a fixed reservoir after minimal training

### Implementation Guide

#### Prerequisites
- Python with PyTorch/JAX
- Standard RNN implementation (LSTM/GRU or vanilla RNN)

#### Step-by-Step Architecture

```python
import torch
import torch.nn as nn

class CerebellarModule(nn.Module):
    """Feedforward cerebellar-inspired module."""
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, output_dim)
        )
    
    def forward(self, x):
        return self.layers(x)

class CorticalRNN(nn.Module):
    """Recurrent cortical core."""
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.rnn = nn.RNN(input_dim, hidden_dim, batch_first=True)
    
    def forward(self, x, h0=None):
        return self.rnn(x, h0)

class CBRNN(nn.Module):
    """Cortico-Cerebellar Recurrent Neural Network."""
    def __init__(self, input_dim, cortical_hidden, cerebellar_hidden, output_dim):
        super().__init__()
        self.cortex = CorticalRNN(input_dim, cortical_hidden)
        self.cerebellum = CerebellarModule(cortical_hidden, cerebellar_hidden, output_dim)
    
    def forward(self, x, h0=None, freeze_cortex=False):
        if freeze_cortex:
            with torch.no_grad():
                cortical_out, hidden = self.cortex(x, h0)
        else:
            cortical_out, hidden = self.cortex(x, h0)
        output = self.cerebellum(cortical_out)
        return output, hidden
    
    def freeze_cortex(self):
        """Freeze cortical core after minimal training."""
        for param in self.cortex.parameters():
            param.requires_grad = False
    
    def unfreeze_cortex(self):
        for param in self.cortex.parameters():
            param.requires_grad = True
```

#### Training Strategy

```python
# Phase 1: Joint training (minimal epochs)
model = CBRNN(input_dim=10, cortical_hidden=64, cerebellar_hidden=32, output_dim=5)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

# Train for minimal epochs to establish cortical representations
for epoch in range(minimal_epochs):
    loss = train_step(model, data, optimizer)

# Phase 2: Freeze cortex, train cerebellar module only
model.freeze_cortex()
cerebellar_optimizer = torch.optim.Adam(model.cerebellum.parameters(), lr=1e-3)

# Cerebellar module drives continued learning
for epoch in range(extended_epochs):
    loss = train_step(model, data, cerebellar_optimizer)
```

## Applications
- **Temporal sequence prediction**: Tasks requiring learning of time-varying patterns
- **Motor control**: Cerebellum-inspired architectures for robotics and movement
- **Efficient continual learning**: Fixed cortical reservoir + adaptable cerebellar module
- **Neuromorphic computing**: Hardware-friendly heterogeneous modular designs
- **Cognitive modeling**: Testing hypotheses about cerebellar-cortical interactions

## Pitfalls
- **Parameter matching**: Fair comparison requires matching total parameters between CB-RNN and baselines
- **Task selection**: Benefits are most pronounced on temporal tasks of varying difficulty; simple tasks may not show advantage
- **Freezing timing**: The optimal point to freeze the cortical core needs empirical tuning
- **Cerebellar module capacity**: Too small a cerebellar module may bottleneck learning; too large defeats the efficiency purpose

## Related Skills
- neural-dynamics-universal-translator
- cornn-convex-rnn-optimization
- low-rank-rnn-learning-dynamics
- resolvent-rnn-multi-hop-sparsity
- neural-brain-framework
- energy-based-neurocomputation