Che differenza pratica c'è tra CSIM e CTIM?

CSIM opera su feature 2D per allineare semantica spaziale (texture RGB) ed edge structure (eventi), usando spatial attention + SS2D. CTIM invece costruisce una sequenza lungo il tempo (Insert, pooling temporale) e applica una scansione S6 bidirezionale, per rendere le predizioni più coerenti quando il motion è forte o la luce è difficile.

Perché "Mamba" è utile qui rispetto a self-attention?

Il paper motiva Mamba/SSM come alternativa più efficiente alla self-attention quadratic, mantenendo capacità di modellare dipendenze lunghe. In MambaSeg questo si traduce in un backbone con complessità più contenuta e in numeri di efficienza (parametri/MACs) competitivi a parità o migliore accuratezza su DDD17/DSEC.

Quanto è riproducibile il risultato per un singolo ricercatore?

È relativamente accessibile: gli autori dichiarano training su singola RTX-4090D, 60 epoche, e rilasciano codice e pesi. Rimangono però non dichiarati i tempi di training e alcuni dettagli operativi (es. seed, versioni esatte), quindi la riproduzione "bitwise" dei numeri potrebbe richiedere tuning.

Deep Learning

MambaSeg: segmentazione semantica RGB+Event con Vision Mamba e fusione spazio-temporale DDIM

MambaSeg unisce due encoder Vision Mamba e un modulo DDIM spazio-temporale per segmentazione semantica RGB+event efficiente, SOTA su DDD17/DSEC benchmark.

2 gennaio 2026

In MambaSeg: Harnessing Mamba for Accurate and Efficient Image-Event Semantic Segmentation (arXiv:2512.24243) gli autori propongono un framework dual-branch che usa Mamba/SSM (in particolare VMamba-T) per codificare separatamente immagini RGB ed event streams, e introduce un modulo di fusione DDIM che agisce sia in spazio (CSIM) sia nel tempo (CTIM), riducendo ambiguità cross-modale e costo computazionale.

Perché RGB+Event? Unendo i due, ottieni il meglio di entrambi i mondi: il sistema vede i colori e i dettagli statici grazie all'RGB, ma vede anche in condizioni di buio estremo e cattura movimenti rapidissimi grazie agli Eventi. In contesti come la guida autonoma (es. guidare fuori da un tunnel buio in una giornata di sole), questa combinazione è fondamentale per la sicurezza!

Sui benchmark DDD17 e DSEC, MambaSeg riporta mIoU 77.56% e 75.10% rispettivamente, superando EISNet di +2.53 mIoU su DDD17 e +2.03 mIoU su DSEC, con 25.44M parametri e 15.59G MACs (complessità riportata su DDD17).

Code: https://github.com/CQU-UISC/MambaSeg
Paper: https://arxiv.org/pdf/2512.24243
Weights (Google Drive): DDD17 https://drive.google.com/drive/folders/1NruRGwfK-9_Hi7ksXsptI8akbxdalllB?usp=drive_link
Weights (Google Drive): DSEC https://drive.google.com/drive/folders/11ljdJQapiKJqvMtYbGrdX8aCP2xaO-M8?usp=drive_link
Dataset: DSEC-Semantic https://dsec.ifi.uzh.ch/dsec-semantic/
Dataset: DDD17 README https://docs.google.com/document/d/1HM0CSmjO8nOpUeTvmPjopcBcVCk7KXvLUuiZFS6TWSg/pub

MambaSeg: Obiettivi di ricerca

RQ1: Un backbone Mamba/SSM può battere fusion basate su Transformer per RGB+event semantic segmentation mantenendo efficienza? Sì: MambaSeg riporta SOTA su DDD17 (77.56 mIoU) e DSEC (75.10 mIoU) con 25.44M parametri e 15.59G MACs (su DDD17), migliorando EISNet di 2.53/2.03 mIoU.
RQ2: La fusione solo "spatial" è sufficiente per allineare immagini ed eventi? No: il paper sostiene che trascurare la dinamica temporale degli eventi porta a inconsistenze; CTIM introduce un allineamento temporale esplicito (attention + scan bidirezionale) per migliorare coerenza e ridurre ambiguità.
RQ3: Come rappresentare eventi asincroni in una forma compatibile con encoder vision moderni senza perdere troppo segnale temporale? Con un voxel grid in $\mathbb{R}^{T\times H\times W}$ ottenuto con binning temporale e accumulo per polarità.
- Qui T=10 intervalli (50ms fissi su DDD17, 100k eventi per bin su DSEC) nel setup sperimentale. Immagina di prendere un lasso di tempo (es. 50 millisecondi) e di affettarlo in $T$ fette (qui $T=10$ ). H x W: Sono l'altezza e la larghezza dell'immagine (lo spazio), T: È la profondità temporale. Invece di schiacciare tutto in un'unica immagine piatta (perdendo l'informazione di quando è successo cosa), si mantengono 10 "livelli".
- Gli eventi hanno una "polarità", +1 (Positivo) significa che il pixel è diventato più luminoso, -1 più scuro.

MambaSeg: Cosa ne pensa Mauro?

Novelty
- Pro: l'idea "forte" è sostituire backbone Transformer con Vision Mamba per ottenere fusion RGB+event (eventi catturati da sensori in real time) a costo più basso, e soprattutto formalizzare una fusione dual-dimension: spatial (CSIM) + temporal (CTIM), con scansioni bidirezionali (S6) sul tempo.
- Contro: gran parte dei blocchi (VMamba-T, SegFormer decoder, voxel grid) sono componenti note; il contributo principale è nel design della fusione e nell'integrazione Mamba+attention, più che in un nuovo paradigma di rappresentazione degli eventi.
Clarity
- Pro: la pipeline è descritta con formule esplicite (voxel grid, attention weights, residual update) e con una separazione pulita CSIM/CTIM.
- Contro: alcune notazioni risultano ambigue (es. nella formula di cross-modal spatial interaction F dovrebbe rappresentare le feature RGB ed eventi), e il paper è molto "dense" in poco spazio (9 pagine).
Reproducibility
- Pro: il codice è pubblico e vengono linkati anche pesi pre-addestrati su DDD17/DSEC (Drive).
- Contro: la disponibilità a lungo termine dei pesi su Drive ..?
Affordability
- Pro: gli autori dichiarano training su singola NVIDIA RTX-4090D, 60 epoche, batch size moderati (DDD17 bs=12, DSEC bs=4). Questo è "lab-friendly".
- Contro: non sono riportati training hours, consumo energetico, né un costo stimato; senza questi dati il budget rimane non quantificabile.
- Nota sui dati: DDD17 e DSEC sono pubblici; non sono menzionati dataset privati per l'addestramento principale.

MambaSeg: Metodi e tecniche

Input: RGB frame + Event voxel grid

L'immagine è trattata come tensore $I\in\mathbb{R}^{C\times H\times W}$ . Gli eventi grezzi $e_i=(x_i,y_i,t_i,p_i)$ (polarità $p_i\in{-1,+1}$ ) vengono convertiti in voxel grid $E\in\mathbb{R}^{T\times H\times W}$ con accumulo per bin temporale.

E(t,x,y)=\sum_{j=1}^{N}\delta(x_j=x, y_j=y)\cdot\delta(t_j\in B_t)\cdot p_j

Dove $B_t$ è l'intervallo del bin temporale t e $\delta(\cdot)$ è la Kronecker delta (È una funzione di due variabili, solitamente indici interi, come $i$ e $j$ che vale 1 se i due indici sono uguali $i = j$ e 0 se sono diversi).

Pseudo-code (voxelizzazione, stile PyTorch):

# events: [N,4] with (x,y,t,p), t normalized or in seconds
# bins: T, H, W
E = torch.zeros(T, H, W, device=events.device)

# assume we already computed bin_id per event in [0, T-1]
x, y, bin_id, p = events[:,0].long(), events[:,1].long(), events[:,2].long(), events[:,3].float()
E.index_put_((bin_id, y, x), p, accumulate=True)  # (t, y, x)

Backbone: dual-branch VMamba-T + multi-scale fusion

MambaSeg usa due encoder paralleli VMamba-T (pretrained ImageNet-1K), uno per RGB e uno per voxel events, ciascuno con 4 stage di Visual State Space (VSS) blocks; il decoder è un MLP head stile SegFormer.

L'idea architetturale chiave: a ogni scala si applica DDIM (CSIM+CTIM), e le feature fuse vengono "re-iniettate" nello stage successivo per aumentare consistenza cross-modale.

Pseudo-code (forward ad alto livello):

I_feat = I
E_feat = E
multi_scale = []

for stage in stages:               # 4 stages
    I_feat = stage.img_enc(I_feat) # VMamba VSS
    E_feat = stage.evt_enc(E_feat) # VMamba VSS

    I_feat, E_feat, F_fused = DDIM(I_feat, E_feat)  # CSIM + CTIM
    multi_scale.append(F_fused)

logits = segformer_mlp_decoder(multi_scale)

CSIM: Cross-Spatial Interaction Module

CSIM mira a combinare texture dense (RGB) e edge cues (eventi) con una cross-modal spatial attention, poi raffina con SS2D (scan Mamba in 2D) e aggiorna con residual "modality-aware".

Cross-modal spatial attention: si costruiscono 6 mappe (avg/max pooling di Ei, Ii e feature fuse Fi) e si producono pesi spaziali $W_S\in\mathbb{R}^{3\times H\times W}$ .

X_i = [\text{AvgPool}(E_i), \text{MaxPool}(E_i), \text{AvgPool}(I_i), \text{MaxPool}(I_i), \text{AvgPool}(F_i), \text{MaxPool}(F_i)] \in \mathbb{R}^{6\times H \times W}

W_S = \sigma(\text{Conv}_2(\text{ReLU}(\text{Conv}_1(X_i)))) \in \mathbb{R}^{3\times H\times W}

Interazione e fusione tramite prodotti elemento-per-elemento e concatenazione. (Nota: la notazione nel PDF contiene un simbolo incoerente; concettualmente i pesi sono tre mappe per event/image/fused.)
Spatial refinement via SS2D: la feature map viene "unfolded" in sequenze direzionali, processate da S6 blocks e poi ricomposte.

F_s^{S} = \text{SS2D}(F_c^{S})

Modality-aware residual update: split in due rami e applicazione di un modulo SA(·) prima del residual.

E_{i+1}^{S} = E_i + E_s^{S}\odot SA(E_s^{S}), \qquad I_{i+1}^{S} = I_i + I_s^{S}\odot SA(I_s^{S})

CTIM: Cross-Temporal Interaction Module

CTIM forza un allineamento nel tempo, sfruttando pooling/attention lungo l'asse temporale e una bi-directional temporal selective scan (due passaggi S6: forward e backward).

Temporal interleaving con Insert(·): eventi "inseriti" tra canali/step dell'immagine per ottenere $F_i^T\in\mathbb{R}^{2T\times H\times W}$ .

F_i^T = \text{Insert}(E_i, I_i)

Temporal attention weights da max/avg pooling + conv 1x1 + sigmoid, applicate ad entrambe le modalità.

W_F^T = \sigma\Big(\text{Conv}( \text{MaxPool}(F_i^T)) + \text{Conv}(\text{AvgPool}(F_i^T))\Big)\in\mathbb{R}^{T\times 1\times 1}

E_c^T = E_i \odot W_F^T,\qquad I_c^T = I_i \odot W_F^T

Bi-directional scan: concat, flatten spazio → sequenza temporale, S6 forward + S6 su sequenza reverse, somma e reshape.

F_c^T = \text{Concat}(E_c^T, I_c^T)\in\mathbb{R}^{2T\times H\times W}, \quad F_{\text{flat}}^T\in\mathbb{R}^{2T\times HW}

F_{\text{fwd}}^T = S6(F_{\text{flat}}^T),\qquad F_{\text{bwd}}^T = S6(\text{Reverse}(F_{\text{flat}}^T))

F_b^T = \text{Reshape}(F_{\text{fwd}}^T + F_{\text{bwd}}^T)

Residual update con TA(·) dopo split:

E_{i+1}^{T} = E_i + E_b^T\odot TA(E_b^T), \qquad I_{i+1}^{T} = I_i + I_b^T\odot TA(I_b^T)

Training recipe (quello che serve davvero per rifare i numeri)

Framework: PyTorch; optimizer AdamW; loss cross-entropy; 60 epoche su entrambi i dataset.
DDD17: lr=2e-4, bs=12; voxel grid con T=10 bin da 50ms.
DSEC: lr=6e-5, bs=4; voxel grid con T=10 bin, 100k eventi per bin.
Data augmentation: random crop, horizontal flip, random resizing.

MambaSeg: Dataset

DDD17 (DAVIS Driving Dataset 2017): guida in scenari reali con DAVIS (eventi + frame grayscale) a 346x260; annotazioni semantiche generate da un modello pretrained su immagini sincronizzate; nel paper sono riportati 15,950 train pairs e 3,890 test pairs, con 6 classi. Link utile: README ufficiale (licenza inclusa) https://docs.google.com/document/d/1HM0CSmjO8nOpUeTvmPjopcBcVCk7KXvLUuiZFS6TWSg/pub
DSEC-Semantic: sequenze di guida con eventi + immagini RGB 440x640; labels semantiche (set a 11 classi e set a 19 classi, compatibile Cityscapes per evaluation). Nel setup del paper: 8,082 frame train su 8 sequenze e 2,809 frame test su 3 sequenze. Link: https://dsec.ifi.uzh.ch/dsec-semantic/

MambaSeg: Licenze

Code MambaSeg: nella pagina GitHub visibile non emerge una licenza esplicita (assenza di indicazione "License" nel contenuto consultato).
Pesi (Drive): linkati dal repo, ma senza licenza dichiarata nelle pagine di destinazione.
DSEC dataset: dichiarato sotto CC BY-SA 4.0 (uso commerciale consentito con attribuzione e share-alike).
DDD17 dataset: README dichiara CC BY-SA 4.0.

MambaSeg FAQs